datarouter-prov/src/main/java/org/onap/dmaap/datarouter/provisioning/GroupServlet.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 static org.onap.dmaap.datarouter.provisioning.utils.HttpServletUtils.sendResponseError;
  28
  29 import java.io.IOException;
  30 import java.io.InvalidObjectException;
  31 import javax.servlet.http.HttpServletRequest;
  32 import javax.servlet.http.HttpServletResponse;
  33 import org.json.JSONObject;
  34
  35 import org.onap.dmaap.datarouter.provisioning.beans.EventLogRecord;
  36 import org.onap.dmaap.datarouter.provisioning.beans.Group;
  37
  38
  39
  40 /**
  41  * This servlet handles provisioning for the &lt;groups&gt; which is generated by the provisioning
  42  * server to handle the creation and inspection of groups for FEEDS and SUBSCRIPTIONS.
  43  *
  44  * @author Vikram Singh
  45  * @version $Id$
  46  * @version $Id: Group.java,v 1.0 2016/07/19
  47  */
  48 @SuppressWarnings("serial")
  49 public class GroupServlet extends ProxyServlet {
  50
  51     public static final String MISSING_HEADER_MESSAGE = "Missing " + BEHALF_HEADER + " header.";
  52
  53     /**
  54      * DELETE on the &lt;GRUPS&gt; -- not supported.
  55      */
  56     @Override
  57     public void doDelete(HttpServletRequest req, HttpServletResponse resp) {
  58         String message = "DELETE not allowed for the GROUPS.";
  59         EventLogRecord elr = new EventLogRecord(req);
  60         elr.setMessage(message);
  61         elr.setResult(HttpServletResponse.SC_METHOD_NOT_ALLOWED);
  62         eventlogger.error(elr.toString());
  63         sendResponseError(resp, HttpServletResponse.SC_METHOD_NOT_ALLOWED, message, eventlogger);
  64     }
  65
  66     /**
  67      * GET on the the list of groups to a feed/sub.
  68      * See the <i>Groups Collection Query</i> section in the <b>Provisioning API</b>
  69      * document for details on how this method should be invoked.
  70      */
  71     @Override
  72     public void doGet(HttpServletRequest req, HttpServletResponse resp) {
  73         EventLogRecord elr = new EventLogRecord(req);
  74         String message = isAuthorizedForProvisioning(req);
  75         if (message != null) {
  76             elr.setMessage(message);
  77             elr.setResult(HttpServletResponse.SC_FORBIDDEN);
  78             eventlogger.error(elr.toString());
  79             sendResponseError(resp, HttpServletResponse.SC_FORBIDDEN, message, eventlogger);
  80             return;
  81         }
  82         if (isProxyServer()) {
  83             super.doGet(req, resp);
  84             return;
  85         }
  86         String bhdr = req.getHeader(BEHALF_HEADER);
  87         if (bhdr == null) {
  88             elr.setMessage(MISSING_HEADER_MESSAGE);
  89             elr.setResult(HttpServletResponse.SC_BAD_REQUEST);
  90             eventlogger.error(elr.toString());
  91             sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST, MISSING_HEADER_MESSAGE, eventlogger);
  92             return;
  93         }
  94
  95         int groupid = getIdFromPath(req);
  96         if (groupid < 0) {
  97             message = "Missing or bad group number.";
  98             elr.setMessage(message);
  99             elr.setResult(HttpServletResponse.SC_BAD_REQUEST);
 100             eventlogger.error(elr.toString());
 101             sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST, message, eventlogger);
 102             return;
 103         }
 104
 105         Group gup = Group.getGroupById(groupid);
 106         // send response
 107         elr.setResult(HttpServletResponse.SC_OK);
 108         eventlogger.info(elr.toString());
 109         resp.setStatus(HttpServletResponse.SC_OK);
 110         resp.setContentType(GROUPFULL_CONTENT_TYPE);
 111         try {
 112             resp.getOutputStream().print(gup.asJSONObject().toString());
 113         } catch (IOException ioe) {
 114             eventlogger.error("PROV0121 GroupServlet.doGet: " + ioe.getMessage(), ioe);
 115         }
 116
 117     }
 118
 119     /**
 120      * PUT on the &lt;GROUPS&gt; -- not supported.
 121      */
 122     @Override
 123     public void doPut(HttpServletRequest req, HttpServletResponse resp) {
 124         EventLogRecord elr = new EventLogRecord(req);
 125         String message = isAuthorizedForProvisioning(req);
 126         if (message != null) {
 127             elr.setMessage(message);
 128             elr.setResult(HttpServletResponse.SC_FORBIDDEN);
 129             eventlogger.error(elr.toString());
 130             sendResponseError(resp, HttpServletResponse.SC_FORBIDDEN, message, eventlogger);
 131             return;
 132         }
 133         if (isProxyServer()) {
 134             super.doPut(req, resp);
 135             return;
 136         }
 137         String bhdr = req.getHeader(BEHALF_HEADER);
 138         if (bhdr == null) {
 139             elr.setMessage(MISSING_HEADER_MESSAGE);
 140             elr.setResult(HttpServletResponse.SC_BAD_REQUEST);
 141             eventlogger.error(elr.toString());
 142             sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST, MISSING_HEADER_MESSAGE, eventlogger);
 143             return;
 144         }
 145         int groupid = getIdFromPath(req);
 146         if (groupid < 0) {
 147             message = "Missing or bad groupid.";
 148             elr.setMessage(message);
 149             elr.setResult(HttpServletResponse.SC_BAD_REQUEST);
 150             eventlogger.error(elr.toString());
 151             sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST, message, eventlogger);
 152             return;
 153         }
 154         Group oldgup = Group.getGroupById(groupid);
 155         if (oldgup == null) {
 156             message = "Missing or bad group number.";
 157             elr.setMessage(message);
 158             elr.setResult(HttpServletResponse.SC_NOT_FOUND);
 159             eventlogger.error(elr.toString());
 160             sendResponseError(resp, HttpServletResponse.SC_NOT_FOUND, message, eventlogger);
 161             return;
 162         }
 163
 164         // check content type is SUB_CONTENT_TYPE, version 1.0
 165         ContentHeader ch = getContentHeader(req);
 166         String ver = ch.getAttribute("version");
 167         if (!ch.getType().equals(GROUP_BASECONTENT_TYPE) || !("1.0".equals(ver) || "2.0".equals(ver))) {
 168             message = "Incorrect content-type";
 169             elr.setMessage(message);
 170             elr.setResult(HttpServletResponse.SC_UNSUPPORTED_MEDIA_TYPE);
 171             eventlogger.error(elr.toString());
 172             sendResponseError(resp, HttpServletResponse.SC_UNSUPPORTED_MEDIA_TYPE, message, eventlogger);
 173             return;
 174         }
 175         JSONObject jo = getJSONfromInput(req);
 176         if (jo == null) {
 177             message = BAD_JSON;
 178             elr.setMessage(message);
 179             elr.setResult(HttpServletResponse.SC_BAD_REQUEST);
 180             eventlogger.error(elr.toString());
 181             sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST, message, eventlogger);
 182             return;
 183         }
 184         if (intlogger.isDebugEnabled()) {
 185             intlogger.debug(jo.toString());
 186         }
 187         Group gup;
 188         try {
 189             gup = new Group(jo);
 190         } catch (InvalidObjectException e) {
 191             message = e.getMessage();
 192             elr.setMessage(message);
 193             elr.setResult(HttpServletResponse.SC_BAD_REQUEST);
 194             eventlogger.error(elr.toString(), e);
 195             sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST, message, eventlogger);
 196             return;
 197         }
 198         gup.setGroupid(oldgup.getGroupid());
 199         Group gb2 = Group.getGroupMatching(gup, oldgup.getGroupid());
 200         if (gb2 != null) {
 201             eventlogger.warn("PROV0011 Creating a duplicate Group: " + gup.getName());
 202             elr.setResult(HttpServletResponse.SC_BAD_REQUEST);
 203             sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST,"Duplicate Group:" + gup.getName(), eventlogger);
 204             return;
 205         }
 206
 207         // Update Groups table entries
 208         if (doUpdate(gup)) {
 209             // send response
 210             elr.setResult(HttpServletResponse.SC_OK);
 211             eventlogger.info(elr.toString());
 212             resp.setStatus(HttpServletResponse.SC_OK);
 213             resp.setContentType(GROUPFULL_CONTENT_TYPE);
 214             try {
 215                 resp.getOutputStream().print(gup.asJSONObject().toString());
 216             } catch (IOException ioe) {
 217                 eventlogger.error("PROV0122 GroupServlet.doPut: " + ioe.getMessage(), ioe);
 218             }
 219             provisioningDataChanged();
 220         } else {
 221             // Something went wrong with the UPDATE
 222             elr.setResult(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 223             eventlogger.error(elr.toString());
 224             sendResponseError(resp, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, DB_PROBLEM_MSG, eventlogger);
 225         }
 226     }
 227
 228     /**
 229      * POST on the &lt;groups&gt; -- create a new GROUPS to a feed.
 230      * See the <i>Creating a GROUPS</i> section in the <b>Provisioning API</b>
 231      * document for details on how this method should be invoked.
 232      */
 233     @Override
 234     public void doPost(HttpServletRequest req, HttpServletResponse resp) {
 235         EventLogRecord elr = new EventLogRecord(req);
 236         String message = isAuthorizedForProvisioning(req);
 237         if (message != null) {
 238             elr.setMessage(message);
 239             elr.setResult(HttpServletResponse.SC_FORBIDDEN);
 240             eventlogger.error(elr.toString());
 241             sendResponseError(resp, HttpServletResponse.SC_FORBIDDEN, message, eventlogger);
 242             return;
 243         }
 244         if (isProxyServer()) {
 245             super.doPost(req, resp);
 246             return;
 247         }
 248         String bhdr = req.getHeader(BEHALF_HEADER);
 249         if (bhdr == null) {
 250             elr.setMessage(MISSING_HEADER_MESSAGE);
 251             elr.setResult(HttpServletResponse.SC_BAD_REQUEST);
 252             eventlogger.error(elr.toString());
 253             sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST, MISSING_HEADER_MESSAGE, eventlogger);
 254             return;
 255         }
 256
 257         // check content type is SUB_CONTENT_TYPE, version 1.0
 258         ContentHeader ch = getContentHeader(req);
 259         String ver = ch.getAttribute("version");
 260         if (!ch.getType().equals(GROUP_BASECONTENT_TYPE) || !(ver.equals("1.0") || ver.equals("2.0"))) {
 261             intlogger.debug("Content-type is: " + req.getHeader("Content-Type"));
 262             message = "Incorrect content-type";
 263             elr.setMessage(message);
 264             elr.setResult(HttpServletResponse.SC_UNSUPPORTED_MEDIA_TYPE);
 265             eventlogger.error(elr.toString());
 266             sendResponseError(resp, HttpServletResponse.SC_UNSUPPORTED_MEDIA_TYPE, message, eventlogger);
 267             return;
 268         }
 269         JSONObject jo = getJSONfromInput(req);
 270         if (jo == null) {
 271             message = BAD_JSON;
 272             elr.setMessage(message);
 273             elr.setResult(HttpServletResponse.SC_BAD_REQUEST);
 274             eventlogger.error(elr.toString());
 275             sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST, message, eventlogger);
 276             return;
 277         }
 278         if (intlogger.isDebugEnabled()) {
 279             intlogger.debug(jo.toString());
 280         }
 281
 282         Group gup;
 283         try {
 284             gup = new Group(jo);
 285         } catch (InvalidObjectException e) {
 286             message = e.getMessage();
 287             elr.setMessage(message);
 288             elr.setResult(HttpServletResponse.SC_BAD_REQUEST);
 289             eventlogger.error(elr.toString(), e);
 290             sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST, message, eventlogger);
 291             return;
 292         }
 293
 294         // Check if this group already exists; not an error (yet), just warn
 295         Group gb2 = Group.getGroupMatching(gup);
 296         if (gb2 != null) {
 297             eventlogger.warn("PROV0011 Creating a duplicate Group: " + gup.getName());
 298             elr.setResult(HttpServletResponse.SC_BAD_REQUEST);
 299             sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST,"Duplicate Group:" + gup.getName(), eventlogger);
 300             return;
 301         }
 302
 303         // Create GROUPS table entries
 304         if (doInsert(gup)) {
 305             // send response
 306             elr.setResult(HttpServletResponse.SC_CREATED);
 307             eventlogger.info(elr.toString());
 308             resp.setStatus(HttpServletResponse.SC_CREATED);
 309             resp.setContentType(GROUPFULL_CONTENT_TYPE);
 310             try {
 311                 resp.getOutputStream().print(gup.asJSONObject().toString());
 312             } catch (IOException ioe) {
 313                 eventlogger.error("PROV0122 GroupServlet.doPost: " + ioe.getMessage(), ioe);
 314             }
 315             provisioningDataChanged();
 316         } else {
 317             // Something went wrong with the INSERT
 318             elr.setResult(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 319             eventlogger.error(elr.toString());
 320             sendResponseError(resp, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, DB_PROBLEM_MSG, eventlogger);
 321         }
 322     }
 323 }