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