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

   1 /*******************************************************************************\r
   2  * ============LICENSE_START==================================================\r
   3  * * org.onap.dmaap\r
   4  * * ===========================================================================\r
   5  * * Copyright © 2017 AT&T Intellectual Property. All rights reserved.\r
   6  * * ===========================================================================\r
   7  * * Licensed under the Apache License, Version 2.0 (the "License");\r
   8  * * you may not use this file except in compliance with the License.\r
   9  * * You may obtain a copy of the License at\r
  10  * *\r
  11  *  *      http://www.apache.org/licenses/LICENSE-2.0\r
  12  * *\r
  13  *  * Unless required by applicable law or agreed to in writing, software\r
  14  * * distributed under the License is distributed on an "AS IS" BASIS,\r
  15  * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  16  * * See the License for the specific language governing permissions and\r
  17  * * limitations under the License.\r
  18  * * ============LICENSE_END====================================================\r
  19  * *\r
  20  * * ECOMP is a trademark and service mark of AT&T Intellectual Property.\r
  21  * *\r
  22  ******************************************************************************/\r
  23 \r
  24 \r
  25 package org.onap.dmaap.datarouter.provisioning;\r
  26 \r
  27 import static org.onap.dmaap.datarouter.provisioning.utils.HttpServletUtils.sendResponseError;\r
  28 \r
  29 import com.att.eelf.configuration.EELFLogger;\r
  30 import com.att.eelf.configuration.EELFManager;\r
  31 import java.io.IOException;\r
  32 import java.io.InvalidObjectException;\r
  33 import java.net.HttpURLConnection;\r
  34 import java.net.URL;\r
  35 import java.util.ArrayList;\r
  36 import java.util.List;\r
  37 import jakarta.servlet.http.HttpServletRequest;\r
  38 import jakarta.servlet.http.HttpServletResponse;\r
  39 import org.json.JSONException;\r
  40 import org.json.JSONObject;\r
  41 import org.onap.dmaap.datarouter.authz.AuthorizationResponse;\r
  42 import org.onap.dmaap.datarouter.provisioning.beans.EventLogRecord;\r
  43 import org.onap.dmaap.datarouter.provisioning.beans.Subscription;\r
  44 import org.onap.dmaap.datarouter.provisioning.eelf.EelfMsgs;\r
  45 import org.onap.dmaap.datarouter.provisioning.utils.SynchronizerTask;\r
  46 \r
  47 /**\r
  48  * This servlet handles provisioning for the &lt;subscriptionURL&gt; which is generated by the provisioning server to\r
  49  * handle the inspection, modification, and deletion of a particular subscription to a feed. It supports DELETE to\r
  50  * delete a subscription, GET to retrieve information about the subscription, and PUT to modify the subscription.  In DR\r
  51  * 3.0, POST is also supported in order to reset the subscription timers for individual subscriptions.\r
  52  *\r
  53  * @author Robert Eby\r
  54  * @version $Id$\r
  55  */\r
  56 public class SubscriptionServlet extends ProxyServlet {\r
  57 \r
  58     private static final String SUBCNTRL_CONTENT_TYPE = "application/vnd.dmaap-dr.subscription-control";\r
  59     //Adding EELF Logger Rally:US664892\r
  60     private static final EELFLogger eelfLogger = EELFManager.getInstance()\r
  61         .getLogger(SubscriptionServlet.class);\r
  62 \r
  63     /**\r
  64      * DELETE on the &lt;subscriptionUrl&gt; -- delete a subscription. See the <i>Deleting a Subscription</i> section in\r
  65      * the <b>Provisioning API</b> document for details on how this method should be invoked.\r
  66      */\r
  67     @Override\r
  68     public void doDelete(HttpServletRequest req, HttpServletResponse resp) {\r
  69         setIpFqdnRequestIDandInvocationIDForEelf("doDelete", req);\r
  70         eelfLogger.info(EelfMsgs.ENTRY);\r
  71         try {\r
  72             eelfLogger.info(EelfMsgs.MESSAGE_WITH_BEHALF_AND_SUBID,\r
  73                     req.getHeader(BEHALF_HEADER), getIdFromPath(req) + "");\r
  74             EventLogRecord elr = new EventLogRecord(req);\r
  75             String message = isAuthorizedForProvisioning(req);\r
  76             if (message != null) {\r
  77                 elr.setMessage(message);\r
  78                 elr.setResult(HttpServletResponse.SC_FORBIDDEN);\r
  79                 eventlogger.error(elr.toString());\r
  80                 sendResponseError(resp, HttpServletResponse.SC_FORBIDDEN, message, eventlogger);\r
  81                 return;\r
  82             }\r
  83             if (isProxyServer()) {\r
  84                 super.doDelete(req, resp);\r
  85                 return;\r
  86             }\r
  87             String bhdr = req.getHeader(BEHALF_HEADER);\r
  88             if (bhdr == null) {\r
  89                 message = MISSING_ON_BEHALF;\r
  90                 elr.setMessage(message);\r
  91                 elr.setResult(HttpServletResponse.SC_BAD_REQUEST);\r
  92                 eventlogger.error(elr.toString());\r
  93                 sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST, message, eventlogger);\r
  94                 return;\r
  95             }\r
  96             int subid = getIdFromPath(req);\r
  97             if (subid < 0) {\r
  98                 message = BAD_SUB;\r
  99                 elr.setMessage(message);\r
 100                 elr.setResult(HttpServletResponse.SC_BAD_REQUEST);\r
 101                 eventlogger.error(elr.toString());\r
 102                 sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST, message, eventlogger);\r
 103                 return;\r
 104             }\r
 105             Subscription sub = Subscription.getSubscriptionById(subid);\r
 106             if (sub == null) {\r
 107                 message = BAD_SUB;\r
 108                 elr.setMessage(message);\r
 109                 elr.setResult(HttpServletResponse.SC_NOT_FOUND);\r
 110                 eventlogger.error(elr.toString());\r
 111                 sendResponseError(resp, HttpServletResponse.SC_NOT_FOUND, message, eventlogger);\r
 112                 return;\r
 113             }\r
 114             /*\r
 115              * START - AAF changes\r
 116              * TDP EPIC US# 307413\r
 117              * CADI code - check on permissions based on Legacy/AAF users to allow to delete/remove subscription\r
 118              */\r
 119             String aafInstance = sub.getAafInstance();\r
 120             if (aafInstance == null || "".equals(aafInstance) || "legacy".equalsIgnoreCase(aafInstance)) {\r
 121                 AuthorizationResponse aresp = authz.decide(req);\r
 122                 if (!aresp.isAuthorized()) {\r
 123                     message = POLICY_ENGINE;\r
 124                     elr.setMessage(message);\r
 125                     elr.setResult(HttpServletResponse.SC_FORBIDDEN);\r
 126                     eventlogger.error(elr.toString());\r
 127                     sendResponseError(resp, HttpServletResponse.SC_FORBIDDEN, message, eventlogger);\r
 128                     return;\r
 129                 }\r
 130             } else {\r
 131                 String permission = getSubscriberPermission(aafInstance, BaseServlet.DELETE_PERMISSION);\r
 132                 eventlogger.info("SubscriptionServlet.doDelete().. Permission String - " + permission);\r
 133                 if (!req.isUserInRole(permission)) {\r
 134                     message = "AAF disallows access to permission - " + permission;\r
 135                     elr.setMessage(message);\r
 136                     elr.setResult(HttpServletResponse.SC_FORBIDDEN);\r
 137                     eventlogger.error(elr.toString());\r
 138                     sendResponseError(resp, HttpServletResponse.SC_FORBIDDEN, message, eventlogger);\r
 139                     return;\r
 140                 }\r
 141             }\r
 142             /*\r
 143              * END - AAF changes\r
 144              */\r
 145             // Delete Subscription\r
 146             if (doDelete(sub)) {\r
 147                 activeSubs--;\r
 148                 // send response\r
 149                 elr.setResult(HttpServletResponse.SC_NO_CONTENT);\r
 150                 eventlogger.info(elr.toString());\r
 151                 resp.setStatus(HttpServletResponse.SC_NO_CONTENT);\r
 152                 provisioningDataChanged();\r
 153             } else {\r
 154                 // Something went wrong with the DELETE\r
 155                 elr.setResult(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);\r
 156                 eventlogger.error(elr.toString());\r
 157                 sendResponseError(resp, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, DB_PROBLEM_MSG, intlogger);\r
 158             }\r
 159         } finally {\r
 160             eelfLogger.info(EelfMsgs.EXIT);\r
 161         }\r
 162     }\r
 163 \r
 164     /**\r
 165      * GET on the &lt;subscriptionUrl&gt; -- get information about a subscription. See the <i>Retreiving Information\r
 166      * about a Subscription</i> section in the <b>Provisioning API</b> document for details on how this method should be\r
 167      * invoked.\r
 168      */\r
 169     @Override\r
 170     public void doGet(HttpServletRequest req, HttpServletResponse resp) {\r
 171         setIpFqdnRequestIDandInvocationIDForEelf("doGet", req);\r
 172         eelfLogger.info(EelfMsgs.ENTRY);\r
 173         try {\r
 174             eelfLogger.info(EelfMsgs.MESSAGE_WITH_BEHALF_AND_SUBID,\r
 175                     req.getHeader(BEHALF_HEADER), getIdFromPath(req) + "");\r
 176             EventLogRecord elr = new EventLogRecord(req);\r
 177             String message = isAuthorizedForProvisioning(req);\r
 178             if (message != null) {\r
 179                 elr.setMessage(message);\r
 180                 elr.setResult(HttpServletResponse.SC_FORBIDDEN);\r
 181                 eventlogger.error(elr.toString());\r
 182                 sendResponseError(resp, HttpServletResponse.SC_FORBIDDEN, message, eventlogger);\r
 183                 return;\r
 184             }\r
 185             if (isProxyServer()) {\r
 186                 super.doGet(req, resp);\r
 187                 return;\r
 188             }\r
 189             String bhdr = req.getHeader(BEHALF_HEADER);\r
 190             if (bhdr == null) {\r
 191                 message = MISSING_ON_BEHALF;\r
 192                 elr.setMessage(message);\r
 193                 elr.setResult(HttpServletResponse.SC_BAD_REQUEST);\r
 194                 eventlogger.error(elr.toString());\r
 195                 sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST, message, eventlogger);\r
 196                 return;\r
 197             }\r
 198             int subid = getIdFromPath(req);\r
 199             if (subid < 0) {\r
 200                 message = BAD_SUB;\r
 201                 elr.setMessage(message);\r
 202                 elr.setResult(HttpServletResponse.SC_BAD_REQUEST);\r
 203                 eventlogger.error(elr.toString());\r
 204                 sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST, message, eventlogger);\r
 205                 return;\r
 206             }\r
 207             Subscription sub = Subscription.getSubscriptionById(subid);\r
 208             if (sub == null) {\r
 209                 message = BAD_SUB;\r
 210                 elr.setMessage(message);\r
 211                 elr.setResult(HttpServletResponse.SC_NOT_FOUND);\r
 212                 eventlogger.error(elr.toString());\r
 213                 sendResponseError(resp, HttpServletResponse.SC_NOT_FOUND, message, eventlogger);\r
 214                 return;\r
 215             }\r
 216             // Check with the Authorizer\r
 217             AuthorizationResponse aresp = authz.decide(req);\r
 218             if (!aresp.isAuthorized()) {\r
 219                 message = POLICY_ENGINE;\r
 220                 elr.setMessage(message);\r
 221                 elr.setResult(HttpServletResponse.SC_FORBIDDEN);\r
 222                 eventlogger.error(elr.toString());\r
 223                 sendResponseError(resp, HttpServletResponse.SC_FORBIDDEN, message, eventlogger);\r
 224                 return;\r
 225             }\r
 226 \r
 227             // send response\r
 228             elr.setResult(HttpServletResponse.SC_OK);\r
 229             eventlogger.info(elr.toString());\r
 230             resp.setStatus(HttpServletResponse.SC_OK);\r
 231             resp.setContentType(SUBFULL_CONTENT_TYPE);\r
 232             try {\r
 233                 resp.getOutputStream().print(sub.asJSONObject(true).toString());\r
 234             } catch (IOException ioe) {\r
 235                 eventlogger.error("PROV0191 SubscriptionServlet.doGet: " + ioe.getMessage(), ioe);\r
 236             }\r
 237         } finally {\r
 238             eelfLogger.info(EelfMsgs.EXIT);\r
 239         }\r
 240     }\r
 241 \r
 242     /**\r
 243      * PUT on the &lt;subscriptionUrl&gt; -- modify a subscription. See the <i>Modifying a Subscription</i> section in\r
 244      * the <b>Provisioning API</b> document for details on how this method should be invoked.\r
 245      */\r
 246     @Override\r
 247     public void doPut(HttpServletRequest req, HttpServletResponse resp) {\r
 248         setIpFqdnRequestIDandInvocationIDForEelf("doPut", req);\r
 249         eelfLogger.info(EelfMsgs.ENTRY);\r
 250         try {\r
 251             eelfLogger.info(EelfMsgs.MESSAGE_WITH_BEHALF_AND_SUBID,\r
 252                     req.getHeader(BEHALF_HEADER), getIdFromPath(req) + "");\r
 253             EventLogRecord elr = new EventLogRecord(req);\r
 254             String message = isAuthorizedForProvisioning(req);\r
 255             if (message != null) {\r
 256                 elr.setMessage(message);\r
 257                 elr.setResult(HttpServletResponse.SC_FORBIDDEN);\r
 258                 eventlogger.error(elr.toString());\r
 259                 sendResponseError(resp, HttpServletResponse.SC_FORBIDDEN, message, eventlogger);\r
 260                 return;\r
 261             }\r
 262             if (isProxyServer()) {\r
 263                 super.doPut(req, resp);\r
 264                 return;\r
 265             }\r
 266             String bhdr = req.getHeader(BEHALF_HEADER);\r
 267             if (bhdr == null) {\r
 268                 message = MISSING_ON_BEHALF;\r
 269                 elr.setMessage(message);\r
 270                 elr.setResult(HttpServletResponse.SC_BAD_REQUEST);\r
 271                 eventlogger.error(elr.toString());\r
 272                 sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST, message, eventlogger);\r
 273                 return;\r
 274             }\r
 275             int subid = getIdFromPath(req);\r
 276             if (subid < 0) {\r
 277                 message = BAD_SUB;\r
 278                 elr.setMessage(message);\r
 279                 elr.setResult(HttpServletResponse.SC_BAD_REQUEST);\r
 280                 eventlogger.error(elr.toString());\r
 281                 sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST, message, eventlogger);\r
 282                 return;\r
 283             }\r
 284             Subscription oldsub = Subscription.getSubscriptionById(subid);\r
 285             if (oldsub == null) {\r
 286                 message = BAD_SUB;\r
 287                 elr.setMessage(message);\r
 288                 elr.setResult(HttpServletResponse.SC_NOT_FOUND);\r
 289                 eventlogger.error(elr.toString());\r
 290                 sendResponseError(resp, HttpServletResponse.SC_NOT_FOUND, message, eventlogger);\r
 291                 return;\r
 292             }\r
 293             // check content type is SUB_CONTENT_TYPE, version 1.0\r
 294             ContentHeader ch = getContentHeader(req);\r
 295             String ver = ch.getAttribute("version");\r
 296             if (!ch.getType().equals(SUB_BASECONTENT_TYPE) || !("1.0".equals(ver) || "2.0".equals(ver))) {\r
 297                 message = "Incorrect content-type";\r
 298                 elr.setMessage(message);\r
 299                 elr.setResult(HttpServletResponse.SC_UNSUPPORTED_MEDIA_TYPE);\r
 300                 eventlogger.error(elr.toString());\r
 301                 sendResponseError(resp, HttpServletResponse.SC_UNSUPPORTED_MEDIA_TYPE, message, eventlogger);\r
 302                 return;\r
 303             }\r
 304             JSONObject jo = getJSONfromInput(req);\r
 305             if (jo == null) {\r
 306                 message = BAD_JSON;\r
 307                 elr.setMessage(message);\r
 308                 elr.setResult(HttpServletResponse.SC_BAD_REQUEST);\r
 309                 eventlogger.error(elr.toString());\r
 310                 sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST, message, eventlogger);\r
 311                 return;\r
 312             }\r
 313             Subscription sub;\r
 314             try {\r
 315                 sub = new Subscription(jo);\r
 316             } catch (InvalidObjectException e) {\r
 317                 message = e.getMessage();\r
 318                 elr.setMessage(message);\r
 319                 elr.setResult(HttpServletResponse.SC_BAD_REQUEST);\r
 320                 eventlogger.error(elr.toString(), e);\r
 321                 sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST, message, eventlogger);\r
 322                 return;\r
 323             }\r
 324 \r
 325             /*\r
 326              * START - AAF changes\r
 327              * TDP EPIC US# 307413\r
 328              * CADI code - check on permissions based on Legacy/AAF users to allow to delete/remove subscription\r
 329              */\r
 330             String aafInstance = sub.getAafInstance();\r
 331             if (aafInstance == null || "".equals(aafInstance) || "legacy".equalsIgnoreCase(aafInstance)) {\r
 332                 AuthorizationResponse aresp = authz.decide(req);\r
 333                 if (!aresp.isAuthorized()) {\r
 334                     message = POLICY_ENGINE;\r
 335                     elr.setMessage(message);\r
 336                     elr.setResult(HttpServletResponse.SC_FORBIDDEN);\r
 337                     eventlogger.error(elr.toString());\r
 338                     sendResponseError(resp, HttpServletResponse.SC_FORBIDDEN, message, eventlogger);\r
 339                     return;\r
 340                 }\r
 341             } else {\r
 342                 String permission = getSubscriberPermission(aafInstance, BaseServlet.EDIT_PERMISSION);\r
 343                 eventlogger.info("SubscriptionServlet.doDelete().. Permission String - " + permission);\r
 344                 if (!req.isUserInRole(permission)) {\r
 345                     message = "AAF disallows access to permission - " + permission;\r
 346                     elr.setMessage(message);\r
 347                     elr.setResult(HttpServletResponse.SC_FORBIDDEN);\r
 348                     eventlogger.error(elr.toString());\r
 349                     sendResponseError(resp, HttpServletResponse.SC_FORBIDDEN, message, eventlogger);\r
 350                     return;\r
 351                 }\r
 352             }\r
 353             /*\r
 354              * END - AAF changes\r
 355              */\r
 356             sub.setSubid(oldsub.getSubid());\r
 357             sub.setFeedid(oldsub.getFeedid());\r
 358             sub.setSubscriber(bhdr);    // set from X-DMAAP-DR-ON-BEHALF-OF header\r
 359             //Adding for group feature:Rally US708115\r
 360             String subjectgroup = (req.getHeader("X-DMAAP-DR-ON-BEHALF-OF-GROUP"));\r
 361             if (!oldsub.getSubscriber().equals(sub.getSubscriber()) && subjectgroup == null) {\r
 362                 message = "This subscriber must be modified by the same subscriber that created it.";\r
 363                 elr.setMessage(message);\r
 364                 elr.setResult(HttpServletResponse.SC_BAD_REQUEST);\r
 365                 eventlogger.error(elr.toString());\r
 366                 sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST, message, eventlogger);\r
 367                 return;\r
 368             }\r
 369 \r
 370             // Update SUBSCRIPTIONS table entries\r
 371             if (doUpdate(sub)) {\r
 372                 // send response\r
 373                 elr.setResult(HttpServletResponse.SC_OK);\r
 374                 eventlogger.info(elr.toString());\r
 375                 resp.setStatus(HttpServletResponse.SC_OK);\r
 376                 resp.setContentType(SUBFULL_CONTENT_TYPE);\r
 377                 try {\r
 378                     resp.getOutputStream().print(sub.asLimitedJSONObject().toString());\r
 379                 } catch (IOException ioe) {\r
 380                     eventlogger.error("PROV0192 SubscriptionServlet.doPut: " + ioe.getMessage(), ioe);\r
 381                 }\r
 382 \r
 383                 /**Change Owner ship of Subscriber.     Adding for group feature:Rally US708115*/\r
 384                 if (jo.has("changeowner") && subjectgroup != null) {\r
 385                     try {\r
 386                         Boolean changeowner = (Boolean) jo.get("changeowner");\r
 387                         if (changeowner != null && changeowner.equals(true)) {\r
 388                             sub.setSubscriber(req.getHeader(BEHALF_HEADER));\r
 389                             sub.changeOwnerShip();\r
 390                         }\r
 391                     } catch (JSONException je) {\r
 392                         eventlogger.error("PROV0193 SubscriptionServlet.doPut: " + je.getMessage(), je);\r
 393                     }\r
 394                 }\r
 395                 /***End of change ownership.*/\r
 396 \r
 397                 provisioningDataChanged();\r
 398             } else {\r
 399                 // Something went wrong with the UPDATE\r
 400                 elr.setResult(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);\r
 401                 eventlogger.error(elr.toString());\r
 402                 sendResponseError(resp, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, DB_PROBLEM_MSG, intlogger);\r
 403             }\r
 404         } finally {\r
 405             eelfLogger.info(EelfMsgs.EXIT);\r
 406         }\r
 407     }\r
 408 \r
 409     /**\r
 410      * POST on the &lt;subscriptionUrl&gt; -- control a subscription. See the <i>Resetting a Subscription's Retry\r
 411      * Schedule</i> section in the <b>Provisioning API</b> document for details on how this method should be invoked.\r
 412      */\r
 413     @Override\r
 414     public void doPost(HttpServletRequest req, HttpServletResponse resp) {\r
 415 \r
 416         setIpFqdnRequestIDandInvocationIDForEelf("doPost", req);\r
 417         eelfLogger.info(EelfMsgs.ENTRY);\r
 418         try {\r
 419             eelfLogger.info(EelfMsgs.MESSAGE_WITH_BEHALF, req.getHeader(BEHALF_HEADER));\r
 420             EventLogRecord elr = new EventLogRecord(req);\r
 421             String message = isAuthorizedForProvisioning(req);\r
 422             if (message != null) {\r
 423                 elr.setMessage(message);\r
 424                 elr.setResult(HttpServletResponse.SC_FORBIDDEN);\r
 425                 eventlogger.error(elr.toString());\r
 426                 sendResponseError(resp, HttpServletResponse.SC_FORBIDDEN, message, eventlogger);\r
 427                 return;\r
 428             }\r
 429             if (isProxyServer()) {\r
 430                 super.doPost(req, resp);\r
 431                 return;\r
 432             }\r
 433             String bhdr = req.getHeader(BEHALF_HEADER);\r
 434             if (bhdr == null) {\r
 435                 message = MISSING_ON_BEHALF;\r
 436                 elr.setMessage(message);\r
 437                 elr.setResult(HttpServletResponse.SC_BAD_REQUEST);\r
 438                 eventlogger.error(elr.toString());\r
 439                 sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST, message, eventlogger);\r
 440                 return;\r
 441             }\r
 442             final int subid = getIdFromPath(req);\r
 443             if (subid < 0 || Subscription.getSubscriptionById(subid) == null) {\r
 444                 message = BAD_SUB;\r
 445                 elr.setMessage(message);\r
 446                 elr.setResult(HttpServletResponse.SC_BAD_REQUEST);\r
 447                 eventlogger.error(elr.toString());\r
 448                 sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST, message, eventlogger);\r
 449                 return;\r
 450             }\r
 451             // check content type is SUBCNTRL_CONTENT_TYPE, version 1.0\r
 452             ContentHeader ch = getContentHeader(req);\r
 453             String ver = ch.getAttribute("version");\r
 454             if (!ch.getType().equals(SUBCNTRL_CONTENT_TYPE) || !"1.0".equals(ver)) {\r
 455                 message = "Incorrect content-type";\r
 456                 elr.setMessage(message);\r
 457                 elr.setResult(HttpServletResponse.SC_UNSUPPORTED_MEDIA_TYPE);\r
 458                 eventlogger.error(elr.toString());\r
 459                 sendResponseError(resp, HttpServletResponse.SC_UNSUPPORTED_MEDIA_TYPE, message, eventlogger);\r
 460                 return;\r
 461             }\r
 462             // Check with the Authorizer\r
 463             AuthorizationResponse aresp = authz.decide(req);\r
 464             if (!aresp.isAuthorized()) {\r
 465                 message = POLICY_ENGINE;\r
 466                 elr.setMessage(message);\r
 467                 elr.setResult(HttpServletResponse.SC_FORBIDDEN);\r
 468                 eventlogger.error(elr.toString());\r
 469                 sendResponseError(resp, HttpServletResponse.SC_FORBIDDEN, message, eventlogger);\r
 470                 return;\r
 471             }\r
 472             JSONObject jo = getJSONfromInput(req);\r
 473             if (jo == null) {\r
 474                 message = BAD_JSON;\r
 475                 elr.setMessage(message);\r
 476                 elr.setResult(HttpServletResponse.SC_BAD_REQUEST);\r
 477                 eventlogger.error(elr.toString());\r
 478                 sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST, message, eventlogger);\r
 479                 return;\r
 480             }\r
 481             try {\r
 482                 // Only the active POD sends notifications\r
 483                 boolean active = SynchronizerTask.getSynchronizer().isActive();\r
 484                 boolean bool = jo.getBoolean("failed");\r
 485                 if (active && !bool) {\r
 486                     // Notify all nodes to reset the subscription\r
 487                     SubscriberNotifyThread thread = new SubscriberNotifyThread();\r
 488                     thread.resetSubscription(subid);\r
 489                     thread.start();\r
 490                 }\r
 491                 // send response\r
 492                 elr.setResult(HttpServletResponse.SC_ACCEPTED);\r
 493                 eventlogger.info(elr.toString());\r
 494                 resp.setStatus(HttpServletResponse.SC_ACCEPTED);\r
 495             } catch (JSONException e) {\r
 496                 message = BAD_JSON;\r
 497                 elr.setMessage(message);\r
 498                 elr.setResult(HttpServletResponse.SC_BAD_REQUEST);\r
 499                 eventlogger.error(elr.toString(), e);\r
 500                 sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST, message, eventlogger);\r
 501             }\r
 502         } finally {\r
 503             eelfLogger.info(EelfMsgs.EXIT);\r
 504         }\r
 505     }\r
 506 \r
 507     /**\r
 508      * A Thread class used to serially send reset notifications to all nodes in the DR network, when a POST is received\r
 509      * for a subscription.\r
 510      */\r
 511     public static class SubscriberNotifyThread extends Thread {\r
 512 \r
 513         static final String URL_TEMPLATE = "http://%s/internal/resetSubscription/%d";\r
 514         private List<String> urls = new ArrayList<>();\r
 515 \r
 516         SubscriberNotifyThread() {\r
 517             setName("SubscriberNotifyThread");\r
 518         }\r
 519 \r
 520         void resetSubscription(int subid) {\r
 521             for (String nodename : BaseServlet.getNodes()) {\r
 522                 String url = String.format(URL_TEMPLATE, nodename, subid);\r
 523                 urls.add(url);\r
 524             }\r
 525         }\r
 526 \r
 527         @Override\r
 528         public void run() {\r
 529             try {\r
 530                 while (!urls.isEmpty()) {\r
 531                     String url = urls.remove(0);\r
 532                     forceGetThrough(url);\r
 533                 }\r
 534             } catch (Exception e) {\r
 535                 intlogger.warn("PROV0195 Caught exception in SubscriberNotifyThread: " + e.getMessage(), e);\r
 536             }\r
 537         }\r
 538 \r
 539         private void forceGetThrough(String url) {\r
 540             try {\r
 541                 URL urlObj = new URL(url);\r
 542                 HttpURLConnection conn = (HttpURLConnection) urlObj.openConnection();\r
 543                 conn.connect();\r
 544                 conn.getContentLength();    // Force the GET through\r
 545                 conn.disconnect();\r
 546             } catch (IOException e) {\r
 547                 intlogger.info("PROV0194 Error accessing URL: " + url + ": " + e.getMessage(), e);\r
 548             }\r
 549         }\r
 550     }\r
 551 }\r