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