datarouter-prov/src/main/java/org/onap/dmaap/datarouter/provisioning/SynchronizerTask.java

   1 /*******************************************************************************
   2  * ============LICENSE_START==================================================
   3  * * org.onap.dmaap
   4  * * ===========================================================================
   5  * * Copyright © 2017 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  * * ECOMP is a trademark and service mark of AT&T Intellectual Property.
  21  * *
  22  ******************************************************************************/
  23
  24
  25 package org.onap.dmaap.datarouter.provisioning;
  26
  27 import java.io.ByteArrayOutputStream;
  28 import java.io.File;
  29 import java.io.FileInputStream;
  30 import java.io.InputStream;
  31 import java.net.InetAddress;
  32 import java.net.UnknownHostException;
  33 import java.nio.file.Files;
  34 import java.nio.file.Path;
  35 import java.nio.file.Paths;
  36 import java.nio.file.StandardCopyOption;
  37 import java.security.KeyStore;
  38 import java.sql.Connection;
  39 import java.sql.SQLException;
  40 import java.util.ArrayList;
  41 import java.util.Arrays;
  42 import java.util.Collection;
  43 import java.util.HashMap;
  44 import java.util.Map;
  45 import java.util.Properties;
  46 import java.util.Set;
  47 import java.util.Timer;
  48 import java.util.TimerTask;
  49 import java.util.TreeSet;
  50
  51 import javax.servlet.http.HttpServletResponse;
  52
  53 import com.att.eelf.configuration.EELFLogger;
  54 import com.att.eelf.configuration.EELFManager;
  55 import org.apache.http.HttpEntity;
  56 import org.apache.http.HttpResponse;
  57 import org.apache.http.client.methods.HttpGet;
  58 import org.apache.http.client.methods.HttpPost;
  59 import org.apache.http.conn.scheme.Scheme;
  60 import org.apache.http.conn.ssl.SSLSocketFactory;
  61 import org.apache.http.entity.ByteArrayEntity;
  62 import org.apache.http.entity.ContentType;
  63 import org.apache.http.impl.client.AbstractHttpClient;
  64 import org.apache.http.impl.client.DefaultHttpClient;
  65 import org.json.JSONArray;
  66 import org.json.JSONException;
  67 import org.json.JSONObject;
  68 import org.json.JSONTokener;
  69 import org.onap.dmaap.datarouter.provisioning.beans.EgressRoute;
  70 import org.onap.dmaap.datarouter.provisioning.beans.Feed;
  71 import org.onap.dmaap.datarouter.provisioning.beans.Group;
  72 import org.onap.dmaap.datarouter.provisioning.beans.IngressRoute;
  73 import org.onap.dmaap.datarouter.provisioning.beans.NetworkRoute;
  74 import org.onap.dmaap.datarouter.provisioning.beans.Parameters;
  75 import org.onap.dmaap.datarouter.provisioning.beans.Subscription;
  76 import org.onap.dmaap.datarouter.provisioning.beans.Syncable;
  77 import org.onap.dmaap.datarouter.provisioning.utils.DB;
  78 import org.onap.dmaap.datarouter.provisioning.utils.LogfileLoader;
  79 import org.onap.dmaap.datarouter.provisioning.utils.RLEBitSet;
  80 import org.onap.dmaap.datarouter.provisioning.utils.URLUtilities;
  81
  82 /**
  83  * This class handles synchronization between provisioning servers (PODs).  It has three primary functions:
  84  * <ol>
  85  * <li>Checking DNS once per minute to see which POD the DNS CNAME points to. The CNAME will point to
  86  * the active (master) POD.</li>
  87  * <li>On non-master (standby) PODs, fetches provisioning data and logs in order to keep MariaDB in sync.</li>
  88  * <li>Providing information to other parts of the system as to the current role (ACTIVE, STANDBY, UNKNOWN)
  89  * of this POD.</li>
  90  * </ol>
  91  * <p>For this to work correctly, the following code needs to be placed at the beginning of main().</p>
  92  * <code>
  93  * Security.setProperty("networkaddress.cache.ttl", "10");
  94  * </code>
  95  *
  96  * @author Robert Eby
  97  * @version $Id: SynchronizerTask.java,v 1.10 2014/03/21 13:50:10 eby Exp $
  98  */
  99 public class SynchronizerTask extends TimerTask {
 100
 101     /**
 102      * This is a singleton -- there is only one SynchronizerTask object in the server
 103      */
 104     private static SynchronizerTask synctask;
 105
 106     /**
 107      * This POD is unknown -- not on the list of PODs
 108      */
 109     public static final int UNKNOWN = 0;
 110     /**
 111      * This POD is active -- on the list of PODs, and the DNS CNAME points to us
 112      */
 113     public static final int ACTIVE = 1;
 114     /**
 115      * This POD is standby -- on the list of PODs, and the DNS CNAME does not point to us
 116      */
 117     public static final int STANDBY = 2;
 118     private static final String[] stnames = {"UNKNOWN", "ACTIVE", "STANDBY"};
 119     private static final long ONE_HOUR = 60 * 60 * 1000L;
 120
 121     private final EELFLogger logger;
 122     private final Timer rolex;
 123     private final String spooldir;
 124     private int state;
 125     private boolean doFetch;
 126     private long nextsynctime;
 127     private AbstractHttpClient httpclient = null;
 128
 129     /**
 130      * Get the singleton SynchronizerTask object.
 131      *
 132      * @return the SynchronizerTask
 133      */
 134     public static synchronized SynchronizerTask getSynchronizer() {
 135         if (synctask == null) {
 136             synctask = new SynchronizerTask();
 137         }
 138         return synctask;
 139     }
 140
 141     @SuppressWarnings("deprecation")
 142     private SynchronizerTask() {
 143         logger = EELFManager.getInstance().getLogger("InternalLog");
 144         rolex = new Timer();
 145         spooldir = (new DB()).getProperties().getProperty("org.onap.dmaap.datarouter.provserver.spooldir");
 146         state = UNKNOWN;
 147         doFetch = true;        // start off with a fetch
 148         nextsynctime = 0;
 149
 150         logger.info("PROV5000: Sync task starting, server state is UNKNOWN");
 151         try {
 152             Properties props = (new DB()).getProperties();
 153             String type = props.getProperty(Main.KEYSTORE_TYPE_PROPERTY, "jks");
 154             String store = props.getProperty(Main.KEYSTORE_PATH_PROPERTY);
 155             String pass = props.getProperty(Main.KEYSTORE_PASS_PROPERTY);
 156             KeyStore keyStore = KeyStore.getInstance(type);
 157             try(FileInputStream instream = new FileInputStream(new File(store))) {
 158                 keyStore.load(instream, pass.toCharArray());
 159
 160             }
 161                 store = props.getProperty(Main.TRUSTSTORE_PATH_PROPERTY);
 162                 pass = props.getProperty(Main.TRUSTSTORE_PASS_PROPERTY);
 163                 KeyStore trustStore = null;
 164                 if (store != null && store.length() > 0) {
 165                     trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
 166                     try(FileInputStream instream = new FileInputStream(new File(store))){
 167                         trustStore.load(instream, pass.toCharArray());
 168
 169                     }
 170                 }
 171
 172             // We are connecting with the node name, but the certificate will have the CNAME
 173             // So we need to accept a non-matching certificate name
 174             String keystorepass = props.getProperty(
 175                 Main.KEYSTORE_PASS_PROPERTY); //itrack.web.att.com/browse/DATARTR-6 for changing hard coded passphase ref
 176            try(AbstractHttpClient hc = new DefaultHttpClient()) {
 177                SSLSocketFactory socketFactory =
 178                        (trustStore == null)
 179                                ? new SSLSocketFactory(keyStore, keystorepass)
 180                                : new SSLSocketFactory(keyStore, keystorepass, trustStore);
 181                socketFactory.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
 182                Scheme sch = new Scheme("https", 443, socketFactory);
 183                hc.getConnectionManager().getSchemeRegistry().register(sch);
 184             httpclient = hc;
 185            }
 186             // Run once every 5 seconds to check DNS, etc.
 187             long interval = 0;
 188             try {
 189                 String s = props.getProperty("org.onap.dmaap.datarouter.provserver.sync_interval", "5000");
 190                 interval = Long.parseLong(s);
 191             } catch (NumberFormatException e) {
 192                 interval = 5000L;
 193             }
 194             rolex.scheduleAtFixedRate(this, 0L, interval);
 195         } catch (Exception e) {
 196             logger.warn("PROV5005: Problem starting the synchronizer: " + e);
 197         }
 198     }
 199
 200     /**
 201      * What is the state of this POD?
 202      *
 203      * @return one of ACTIVE, STANDBY, UNKNOWN
 204      */
 205     public int getState() {
 206         return state;
 207     }
 208
 209     /**
 210      * Is this the active POD?
 211      *
 212      * @return true if we are active (the master), false otherwise
 213      */
 214     public boolean isActive() {
 215         return state == ACTIVE;
 216     }
 217
 218     /**
 219      * This method is used to signal that another POD (the active POD) has sent us a /fetchProv request, and that we
 220      * should re-synchronize with the master.
 221      */
 222     public void doFetch() {
 223         doFetch = true;
 224     }
 225
 226     /**
 227      * Runs once a minute in order to <ol>
 228      * <li>lookup DNS names,</li>
 229      * <li>determine the state of this POD,</li>
 230      * <li>if this is a standby POD, and the fetch flag is set, perform a fetch of state from the active POD.</li>
 231      * <li>if this is a standby POD, check if there are any new log records to be replicated.</li>
 232      * </ol>
 233      */
 234     @Override
 235     public void run() {
 236         try {
 237             state = lookupState();
 238             if (state == STANDBY) {
 239                 // Only copy provisioning data FROM the active server TO the standby
 240                 if (doFetch || (System.currentTimeMillis() >= nextsynctime)) {
 241                     logger.debug("Initiating a sync...");
 242                     JSONObject jo = readProvisioningJSON();
 243                     if (jo != null) {
 244                         doFetch = false;
 245                         syncFeeds(jo.getJSONArray("feeds"));
 246                         syncSubs(jo.getJSONArray("subscriptions"));
 247                         syncGroups(jo.getJSONArray("groups")); //Rally:US708115 - 1610
 248                         syncParams(jo.getJSONObject("parameters"));
 249                         // The following will not be present in a version=1.0 provfeed
 250                         JSONArray ja = jo.optJSONArray("ingress");
 251                         if (ja != null) {
 252                             syncIngressRoutes(ja);
 253                         }
 254                         JSONObject j2 = jo.optJSONObject("egress");
 255                         if (j2 != null) {
 256                             syncEgressRoutes(j2);
 257                         }
 258                         ja = jo.optJSONArray("routing");
 259                         if (ja != null) {
 260                             syncNetworkRoutes(ja);
 261                         }
 262                     }
 263                     logger.info("PROV5013: Sync completed.");
 264                     nextsynctime = System.currentTimeMillis() + ONE_HOUR;
 265                 }
 266             } else {
 267                 // Don't do fetches on non-standby PODs
 268                 doFetch = false;
 269             }
 270
 271             // Fetch DR logs as needed - server to server
 272             LogfileLoader lfl = LogfileLoader.getLoader();
 273             if (lfl.isIdle()) {
 274                 // Only fetch new logs if the loader is waiting for them.
 275                 logger.trace("Checking for logs to replicate...");
 276                 RLEBitSet local = lfl.getBitSet();
 277                 RLEBitSet remote = readRemoteLoglist();
 278                 remote.andNot(local);
 279                 if (!remote.isEmpty()) {
 280                     logger.debug(" Replicating logs: " + remote);
 281                     replicateDRLogs(remote);
 282                 }
 283             }
 284         } catch (Exception e) {
 285             logger.warn("PROV0020: Caught exception in SynchronizerTask: " + e);
 286         }
 287     }
 288
 289     /**
 290      * This method is used to lookup the CNAME that points to the active server. It returns 0 (UNKNOWN), 1(ACTIVE), or 2
 291      * (STANDBY) to indicate the state of this server.
 292      *
 293      * @return the current state
 294      */
 295     private int lookupState() {
 296         int newstate = UNKNOWN;
 297         try {
 298             InetAddress myaddr = InetAddress.getLocalHost();
 299             if (logger.isTraceEnabled()) {
 300                 logger.trace("My address: " + myaddr);
 301             }
 302             String thisPod = myaddr.getHostName();
 303             Set<String> pods = new TreeSet<>(Arrays.asList(BaseServlet.getPods()));
 304             if (pods.contains(thisPod)) {
 305                 InetAddress pserver = InetAddress.getByName(BaseServlet.getActiveProvName());
 306                 newstate = myaddr.equals(pserver) ? ACTIVE : STANDBY;
 307                 if (logger.isDebugEnabled() && System.currentTimeMillis() >= nextMsg) {
 308                     logger.debug("Active POD = " + pserver + ", Current state is " + stnames[newstate]);
 309                     nextMsg = System.currentTimeMillis() + (5 * 60 * 1000L);
 310                 }
 311             } else {
 312                 logger.warn("PROV5003: My name (" + thisPod + ") is missing from the list of provisioning servers.");
 313             }
 314         } catch (UnknownHostException e) {
 315             logger.warn("PROV5002: Cannot determine the name of this provisioning server.");
 316         }
 317
 318         if (newstate != state) {
 319             logger
 320                 .info(String.format("PROV5001: Server state changed from %s to %s", stnames[state], stnames[newstate]));
 321         }
 322         return newstate;
 323     }
 324
 325     private static long nextMsg = 0;    // only display the "Current state" msg every 5 mins.
 326
 327     /**
 328      * Synchronize the Feeds in the JSONArray, with the Feeds in the DB.
 329      */
 330     private void syncFeeds(JSONArray ja) {
 331         Collection<Syncable> coll = new ArrayList<>();
 332         for (int n = 0; n < ja.length(); n++) {
 333             try {
 334                 Feed f = new Feed(ja.getJSONObject(n));
 335                 coll.add(f);
 336             } catch (Exception e) {
 337                 logger.warn("PROV5004: Invalid object in feed: " + ja.optJSONObject(n));
 338             }
 339         }
 340         if (sync(coll, Feed.getAllFeeds())) {
 341             BaseServlet.provisioningDataChanged();
 342         }
 343     }
 344
 345     /**
 346      * Synchronize the Subscriptions in the JSONArray, with the Subscriptions in the DB.
 347      */
 348     private void syncSubs(JSONArray ja) {
 349         Collection<Syncable> coll = new ArrayList<>();
 350         for (int n = 0; n < ja.length(); n++) {
 351             try {
 352                 //Data Router Subscriber HTTPS Relaxation feature USERSTORYID:US674047.
 353                 JSONObject j = ja.getJSONObject(n);
 354                 j.put("sync", "true");
 355                 Subscription s = new Subscription(j);
 356                 coll.add(s);
 357             } catch (Exception e) {
 358                 logger.warn("PROV5004: Invalid object in subscription: " + ja.optJSONObject(n));
 359             }
 360         }
 361         if (sync(coll, Subscription.getAllSubscriptions())) {
 362             BaseServlet.provisioningDataChanged();
 363         }
 364     }
 365
 366     /**
 367      * Rally:US708115  - Synchronize the Groups in the JSONArray, with the Groups in the DB.
 368      */
 369     private void syncGroups(JSONArray ja) {
 370         Collection<Syncable> coll = new ArrayList<>();
 371         for (int n = 0; n < ja.length(); n++) {
 372             try {
 373                 Group g = new Group(ja.getJSONObject(n));
 374                 coll.add(g);
 375             } catch (Exception e) {
 376                 logger.warn("PROV5004: Invalid object in subscription: " + ja.optJSONObject(n));
 377             }
 378         }
 379         if (sync(coll, Group.getAllgroups())) {
 380             BaseServlet.provisioningDataChanged();
 381         }
 382     }
 383
 384
 385     /**
 386      * Synchronize the Parameters in the JSONObject, with the Parameters in the DB.
 387      */
 388     private void syncParams(JSONObject jo) {
 389         Collection<Syncable> coll = new ArrayList<>();
 390         for (String k : jo.keySet()) {
 391             String v = "";
 392             try {
 393                 v = jo.getString(k);
 394             } catch (JSONException e) {
 395                 try {
 396                     v = "" + jo.getInt(k);
 397                 } catch (JSONException e1) {
 398                     JSONArray ja = jo.getJSONArray(k);
 399                     for (int i = 0; i < ja.length(); i++) {
 400                         if (i > 0) {
 401                             v += "|";
 402                         }
 403                         v += ja.getString(i);
 404                     }
 405                 }
 406             }
 407             coll.add(new Parameters(k, v));
 408         }
 409         if (sync(coll, Parameters.getParameterCollection())) {
 410             BaseServlet.provisioningDataChanged();
 411             BaseServlet.provisioningParametersChanged();
 412         }
 413     }
 414
 415     private void syncIngressRoutes(JSONArray ja) {
 416         Collection<Syncable> coll = new ArrayList<>();
 417         for (int n = 0; n < ja.length(); n++) {
 418             try {
 419                 IngressRoute in = new IngressRoute(ja.getJSONObject(n));
 420                 coll.add(in);
 421             } catch (NumberFormatException e) {
 422                 logger.warn("PROV5004: Invalid object in ingress routes: " + ja.optJSONObject(n));
 423             }
 424         }
 425         if (sync(coll, IngressRoute.getAllIngressRoutes())) {
 426             BaseServlet.provisioningDataChanged();
 427         }
 428     }
 429
 430     private void syncEgressRoutes(JSONObject jo) {
 431         Collection<Syncable> coll = new ArrayList<>();
 432         for (String key : jo.keySet()) {
 433             try {
 434                 int sub = Integer.parseInt(key);
 435                 String node = jo.getString(key);
 436                 EgressRoute er = new EgressRoute(sub, node);
 437                 coll.add(er);
 438             } catch (NumberFormatException e) {
 439                 logger.warn("PROV5004: Invalid subid in egress routes: " + key);
 440             } catch (IllegalArgumentException e) {
 441                 logger.warn("PROV5004: Invalid node name in egress routes: " + key);
 442             }
 443         }
 444         if (sync(coll, EgressRoute.getAllEgressRoutes())) {
 445             BaseServlet.provisioningDataChanged();
 446         }
 447     }
 448
 449     private void syncNetworkRoutes(JSONArray ja) {
 450         Collection<Syncable> coll = new ArrayList<>();
 451         for (int n = 0; n < ja.length(); n++) {
 452             try {
 453                 NetworkRoute nr = new NetworkRoute(ja.getJSONObject(n));
 454                 coll.add(nr);
 455             } catch (JSONException e) {
 456                 logger.warn("PROV5004: Invalid object in network routes: " + ja.optJSONObject(n));
 457             }
 458         }
 459         if (sync(coll, NetworkRoute.getAllNetworkRoutes())) {
 460             BaseServlet.provisioningDataChanged();
 461         }
 462     }
 463
 464     private boolean sync(Collection<? extends Syncable> newc, Collection<? extends Syncable> oldc) {
 465         boolean changes = false;
 466         try {
 467             Map<String, Syncable> newmap = getMap(newc);
 468             Map<String, Syncable> oldmap = getMap(oldc);
 469             Set<String> union = new TreeSet<>(newmap.keySet());
 470             union.addAll(oldmap.keySet());
 471             DB db = new DB();
 472             @SuppressWarnings("resource")
 473             Connection conn = db.getConnection();
 474             for (String n : union) {
 475                 Syncable newobj = newmap.get(n);
 476                 Syncable oldobj = oldmap.get(n);
 477                 if (oldobj == null) {
 478                     if (logger.isDebugEnabled()) {
 479                         logger.debug("  Inserting record: " + newobj);
 480                     }
 481                     newobj.doInsert(conn);
 482                     changes = true;
 483                 } else if (newobj == null) {
 484                     if (logger.isDebugEnabled()) {
 485                         logger.debug("  Deleting record: " + oldobj);
 486                     }
 487                     oldobj.doDelete(conn);
 488                     changes = true;
 489                 } else if (!newobj.equals(oldobj)) {
 490                     if (logger.isDebugEnabled()) {
 491                         logger.debug("  Updating record: " + newobj);
 492                     }
 493                     newobj.doUpdate(conn);
 494
 495                     /**Rally US708115
 496                      * Change Ownership of FEED - 1610, Syncronised with secondary DB.
 497                      * */
 498                     checkChnageOwner(newobj, oldobj);
 499
 500                     changes = true;
 501                 }
 502             }
 503             db.release(conn);
 504         } catch (SQLException e) {
 505             logger.warn("PROV5009: problem during sync, exception: " + e);
 506         }
 507         return changes;
 508     }
 509
 510     private Map<String, Syncable> getMap(Collection<? extends Syncable> c) {
 511         Map<String, Syncable> map = new HashMap<>();
 512         for (Syncable v : c) {
 513             map.put(v.getKey(), v);
 514         }
 515         return map;
 516     }
 517
 518     /**Change owner of FEED/SUBSCRIPTION*/
 519     /**
 520      * Rally US708115 Change Ownership of FEED - 1610
 521      */
 522     private void checkChnageOwner(Syncable newobj, Syncable oldobj) {
 523         if (newobj instanceof Feed) {
 524             Feed oldfeed = (Feed) oldobj;
 525             Feed newfeed = (Feed) newobj;
 526
 527             if (!oldfeed.getPublisher().equals(newfeed.getPublisher())) {
 528                 logger.info("PROV5013 -  Previous publisher: " + oldfeed.getPublisher() + ": New publisher-" + newfeed
 529                     .getPublisher());
 530                 oldfeed.setPublisher(newfeed.getPublisher());
 531                 oldfeed.changeOwnerShip();
 532             }
 533         } else if (newobj instanceof Subscription) {
 534             Subscription oldsub = (Subscription) oldobj;
 535             Subscription newsub = (Subscription) newobj;
 536
 537             if (!oldsub.getSubscriber().equals(newsub.getSubscriber())) {
 538                 logger.info("PROV5013 -  Previous subscriber: " + oldsub.getSubscriber() + ": New subscriber-" + newsub
 539                     .getSubscriber());
 540                 oldsub.setSubscriber(newsub.getSubscriber());
 541                 oldsub.changeOwnerShip();
 542             }
 543         }
 544
 545     }
 546
 547     /**
 548      * Issue a GET on the peer POD's /internal/prov/ URL to get a copy of its provisioning data.
 549      *
 550      * @return the provisioning data (as a JONObject)
 551      */
 552     private synchronized JSONObject readProvisioningJSON() {
 553         String url = URLUtilities.generatePeerProvURL();
 554         HttpGet get = new HttpGet(url);
 555         try {
 556             HttpResponse response = httpclient.execute(get);
 557             int code = response.getStatusLine().getStatusCode();
 558             if (code != HttpServletResponse.SC_OK) {
 559                 logger.warn("PROV5010: readProvisioningJSON failed, bad error code: " + code);
 560                 return null;
 561             }
 562             HttpEntity entity = response.getEntity();
 563             String ctype = entity.getContentType().getValue().trim();
 564             if (!ctype.equals(BaseServlet.PROVFULL_CONTENT_TYPE1) && !ctype
 565                 .equals(BaseServlet.PROVFULL_CONTENT_TYPE2)) {
 566                 logger.warn("PROV5011: readProvisioningJSON failed, bad content type: " + ctype);
 567                 return null;
 568             }
 569             return new JSONObject(new JSONTokener(entity.getContent()));
 570         } catch (Exception e) {
 571             logger.warn("PROV5012: readProvisioningJSON failed, exception: " + e);
 572             return null;
 573         } finally {
 574             get.releaseConnection();
 575         }
 576     }
 577
 578     /**
 579      * Issue a GET on the peer POD's /internal/drlogs/ URL to get an RELBitSet representing the log records available in
 580      * the remote database.
 581      *
 582      * @return the bitset
 583      */
 584     private RLEBitSet readRemoteLoglist() {
 585         RLEBitSet bs = new RLEBitSet();
 586         String url = URLUtilities.generatePeerLogsURL();
 587
 588         //Fixing if only one Prov is configured, not to give exception to fill logs, return empty bitset.
 589         if (url.equals("")) {
 590             return bs;
 591         }
 592         //End of fix.
 593
 594         HttpGet get = new HttpGet(url);
 595         try {
 596             HttpResponse response = httpclient.execute(get);
 597             int code = response.getStatusLine().getStatusCode();
 598             if (code != HttpServletResponse.SC_OK) {
 599                 logger.warn("PROV5010: readRemoteLoglist failed, bad error code: " + code);
 600                 return bs;
 601             }
 602             HttpEntity entity = response.getEntity();
 603             String ctype = entity.getContentType().getValue().trim();
 604             if (!ctype.equals("text/plain")) {
 605                 logger.warn("PROV5011: readRemoteLoglist failed, bad content type: " + ctype);
 606                 return bs;
 607             }
 608             InputStream is = entity.getContent();
 609             ByteArrayOutputStream bos = new ByteArrayOutputStream();
 610             int ch = 0;
 611             while ((ch = is.read()) >= 0) {
 612                 bos.write(ch);
 613             }
 614             bs.set(bos.toString());
 615             is.close();
 616         } catch (Exception e) {
 617             logger.warn("PROV5012: readRemoteLoglist failed, exception: " + e);
 618             return bs;
 619         } finally {
 620             get.releaseConnection();
 621         }
 622         return bs;
 623     }
 624
 625     /**
 626      * Issue a POST on the peer POD's /internal/drlogs/ URL to fetch log records available in the remote database that
 627      * we wish to copy to the local database.
 628      *
 629      * @param bs the bitset (an RELBitSet) of log records to fetch
 630      */
 631     private void replicateDRLogs(RLEBitSet bs) {
 632         String url = URLUtilities.generatePeerLogsURL();
 633         HttpPost post = new HttpPost(url);
 634         try {
 635             String t = bs.toString();
 636             HttpEntity body = new ByteArrayEntity(t.getBytes(), ContentType.create("text/plain"));
 637             post.setEntity(body);
 638             if (logger.isDebugEnabled()) {
 639                 logger.debug("Requesting records: " + t);
 640             }
 641
 642             HttpResponse response = httpclient.execute(post);
 643             int code = response.getStatusLine().getStatusCode();
 644             if (code != HttpServletResponse.SC_OK) {
 645                 logger.warn("PROV5010: replicateDRLogs failed, bad error code: " + code);
 646                 return;
 647             }
 648             HttpEntity entity = response.getEntity();
 649             String ctype = entity.getContentType().getValue().trim();
 650             if (!ctype.equals("text/plain")) {
 651                 logger.warn("PROV5011: replicateDRLogs failed, bad content type: " + ctype);
 652                 return;
 653             }
 654
 655             String spoolname = "" + System.currentTimeMillis();
 656             Path tmppath = Paths.get(spooldir, spoolname);
 657             Path donepath = Paths.get(spooldir, "IN." + spoolname);
 658             Files.copy(entity.getContent(), Paths.get(spooldir, spoolname), StandardCopyOption.REPLACE_EXISTING);
 659             Files.move(tmppath, donepath, StandardCopyOption.REPLACE_EXISTING);
 660             logger.info("Approximately " + bs.cardinality() + " records replicated.");
 661         } catch (Exception e) {
 662             logger.warn("PROV5012: replicateDRLogs failed, exception: " + e);
 663         } finally {
 664             post.releaseConnection();
 665         }
 666     }
 667 }