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