auth/auth-certman/src/main/java/org/onap/aaf/auth/cm/facade/FacadeImpl.java

   1 /**
   2  * ============LICENSE_START====================================================
   3  * org.onap.aaf
   4  * ===========================================================================
   5  * Copyright (c) 2018 AT&T Intellectual Property. All rights reserved.
   6  * Modifications Copyright (C) 2019 IBM.
   7  * ===========================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END====================================================
  20  *
  21  */
  22
  23 package org.onap.aaf.auth.cm.facade;
  24
  25 import static org.onap.aaf.auth.layer.Result.ERR_ActionNotCompleted;
  26 import static org.onap.aaf.auth.layer.Result.ERR_BadData;
  27 import static org.onap.aaf.auth.layer.Result.ERR_ConflictAlreadyExists;
  28 import static org.onap.aaf.auth.layer.Result.ERR_Denied;
  29 import static org.onap.aaf.auth.layer.Result.ERR_NotFound;
  30 import static org.onap.aaf.auth.layer.Result.ERR_NotImplemented;
  31 import static org.onap.aaf.auth.layer.Result.ERR_Policy;
  32 import static org.onap.aaf.auth.layer.Result.ERR_Security;
  33 import static org.onap.aaf.auth.layer.Result.OK;
  34
  35 import java.io.IOException;
  36
  37 import javax.servlet.http.HttpServletRequest;
  38 import javax.servlet.http.HttpServletResponse;
  39
  40 import org.onap.aaf.auth.cm.AAF_CM;
  41 import org.onap.aaf.auth.cm.ca.CA;
  42 import org.onap.aaf.auth.cm.data.CertResp;
  43 import org.onap.aaf.auth.cm.mapper.Mapper;
  44 import org.onap.aaf.auth.cm.mapper.Mapper.API;
  45 import org.onap.aaf.auth.cm.service.CMService;
  46 import org.onap.aaf.auth.dao.cass.ArtiDAO;
  47 import org.onap.aaf.auth.dao.cass.Status;
  48 import org.onap.aaf.auth.env.AuthzEnv;
  49 import org.onap.aaf.auth.env.AuthzTrans;
  50 import org.onap.aaf.auth.layer.Result;
  51 import org.onap.aaf.cadi.aaf.AAFPermission;
  52 import org.onap.aaf.misc.env.APIException;
  53 import org.onap.aaf.misc.env.Data;
  54 import org.onap.aaf.misc.env.Env;
  55 import org.onap.aaf.misc.env.TimeTaken;
  56 import org.onap.aaf.misc.env.util.Split;
  57 import org.onap.aaf.misc.rosetta.env.RosettaDF;
  58 import org.onap.aaf.misc.rosetta.env.RosettaData;
  59
  60 /**
  61  * AuthzFacade
  62  *
  63  * This Service Facade encapsulates the essence of the API Service can do, and provides
  64  * a single created object for elements such as RosettaDF.
  65  *
  66  * The Responsibilities of this class are to:
  67  * 1) Interact with the Service Implementation (which might be supported by various kinds of Backend Storage)
  68  * 2) Validate incoming data (if applicable)
  69  * 3) Convert the Service response into the right Format, and mark the Content Type
  70  *         a) In the future, we may support multiple Response Formats, aka JSON or XML, based on User Request.
  71  * 4) Log Service info, warnings and exceptions as necessary
  72  * 5) When asked by the API layer, this will create and write Error content to the OutputStream
  73  *
  74  * Note: This Class does NOT set the HTTP Status Code.  That is up to the API layer, so that it can be
  75  * clearly coordinated with the API Documentation
  76  *
  77  * @author Jonathan
  78  *
  79  */
  80 public abstract class FacadeImpl<REQ,CERT,ARTIFACTS,ERROR> extends org.onap.aaf.auth.layer.FacadeImpl implements Facade<REQ,CERT,ARTIFACTS,ERROR>
  81     {
  82     private static final String TRUE = "TRUE";
  83     private static final String REQUEST_CERT = "Request New Certificate";
  84     private static final String RENEW_CERT = "Renew Certificate";
  85     private static final String DROP_CERT = "Drop Certificate";
  86     private static final String READ_CERTS_MECHID = "Read Certificates by MechID";
  87     private static final String CREATE_ARTIFACTS = "Create Deployment Artifact";
  88     private static final String READ_ARTIFACTS = "Read Deployment Artifact";
  89     private static final String UPDATE_ARTIFACTS = "Update Deployment Artifact";
  90     private static final String DELETE_ARTIFACTS = "Delete Deployment Artifact";
  91
  92     private CMService service;
  93
  94     private final RosettaDF<ERROR>         errDF;
  95     private final RosettaDF<REQ>         certRequestDF, certRenewDF, certDropDF;
  96     private final RosettaDF<CERT>        certDF;
  97     private final RosettaDF<ARTIFACTS>    artiDF;
  98     private Mapper<REQ, CERT, ARTIFACTS, ERROR>     mapper;
  99 //    private Slot sCertAuth;
 100     private final String voidResp;
 101
 102     public FacadeImpl(AAF_CM certman,
 103                       CMService service,
 104                       Mapper<REQ,CERT,ARTIFACTS,ERROR> mapper,
 105                       Data.TYPE dataType) throws APIException {
 106         this.service = service;
 107         this.mapper = mapper;
 108         AuthzEnv env = certman.env;
 109         //TODO: Gabe [JUnit] Static issue, talk to Jonathan
 110         (errDF                 = env.newDataFactory(mapper.getClass(API.ERROR))).in(dataType).out(dataType);
 111         (certRequestDF         = env.newDataFactory(mapper.getClass(API.CERT_REQ))).in(dataType).out(dataType);
 112         (certRenewDF         = env.newDataFactory(mapper.getClass(API.CERT_RENEW))).in(dataType).out(dataType);
 113         (certDropDF         = env.newDataFactory(mapper.getClass(API.CERT_DROP))).in(dataType).out(dataType);
 114         (certDF             = env.newDataFactory(mapper.getClass(API.CERT))).in(dataType).out(dataType);
 115         (artiDF             = env.newDataFactory(mapper.getClass(API.ARTIFACTS))).in(dataType).out(dataType);
 116 //        sCertAuth = env.slot(API_Cert.CERT_AUTH);
 117         if (artiDF.getOutType().name().contains("xml")) {
 118             voidResp = "application/Void+xml;charset=utf-8;version=1.0,application/xml;version=1.0,*/*";
 119         } else {
 120             voidResp = "application/Void+json;charset=utf-8;version=1.0,application/json;version=1.0,*/*";
 121         }
 122     }
 123
 124     public Mapper<REQ,CERT,ARTIFACTS,ERROR> mapper() {
 125         return mapper;
 126     }
 127
 128     /* (non-Javadoc)
 129      * @see com.att.authz.facade.AuthzFacade#error(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, int)
 130      *
 131      * Note: Conforms to AT&T TSS RESTful Error Structure
 132      */
 133     @Override
 134     public void error(AuthzTrans trans, HttpServletResponse response, Result<?> result) {
 135         error(trans, response, result.status,
 136                 result.details==null?"":result.details.trim(),
 137                 result.variables==null?Result.EMPTY_VARS:result.variables);
 138     }
 139
 140     @Override
 141     public void error(AuthzTrans trans, HttpServletResponse response, int status, final String _msg, final Object ... _detail) {
 142         String msgId;
 143         String prefix;
 144         boolean hidemsg=false;
 145         switch(status) {
 146             case 202:
 147             case ERR_ActionNotCompleted:
 148                 msgId = "SVC1202";
 149                 prefix = "Accepted, Action not complete";
 150                 response.setStatus(/*httpstatus=*/202);
 151                 break;
 152
 153             case 403:
 154             case ERR_Policy:
 155             case ERR_Security:
 156             case ERR_Denied:
 157                 msgId = "SVC1403";
 158                 prefix = "Forbidden";
 159                 response.setStatus(/*httpstatus=*/403);
 160                 break;
 161
 162             case 404:
 163             case ERR_NotFound:
 164                 msgId = "SVC1404";
 165                 prefix = "Not Found";
 166                 response.setStatus(/*httpstatus=*/404);
 167                 break;
 168
 169             case 406:
 170             case ERR_BadData:
 171                 msgId="SVC1406";
 172                 prefix = "Not Acceptable";
 173                 response.setStatus(/*httpstatus=*/406);
 174                 break;
 175
 176             case 409:
 177             case ERR_ConflictAlreadyExists:
 178                 msgId = "SVC1409";
 179                 prefix = "Conflict Already Exists";
 180                 response.setStatus(/*httpstatus=*/409);
 181                 break;
 182
 183             case 501:
 184             case ERR_NotImplemented:
 185                 msgId = "SVC1501";
 186                 prefix = "Not Implemented";
 187                 response.setStatus(/*httpstatus=*/501);
 188                 break;
 189
 190
 191             default:
 192                 msgId = "SVC1500";
 193                 prefix = "General Service Error";
 194                 response.setStatus(/*httpstatus=*/500);
 195                 hidemsg=true;
 196                 break;
 197         }
 198
 199         try {
 200             StringBuilder holder = new StringBuilder();
 201             ERROR em = mapper().errorFromMessage(holder, msgId,prefix + ": " + _msg,_detail);
 202             trans.checkpoint(
 203                     "ErrResp [" +
 204                     msgId +
 205                     "] " +
 206                     holder.toString(),
 207                     Env.ALWAYS);
 208             if (hidemsg) {
 209                 holder.setLength(0);
 210                 em = mapper().errorFromMessage(holder, msgId, "Server had an issue processing this request");
 211             }
 212             errDF.newData(trans).load(em).to(response.getOutputStream());
 213
 214         } catch (Exception e) {
 215             trans.error().log(e,"unable to send response for",_msg);
 216         }
 217     }
 218
 219     @Override
 220     public Result<Void> check(AuthzTrans trans, HttpServletResponse resp, String perm) throws IOException {
 221         String[] p = Split.split('|',perm);
 222         AAFPermission ap;
 223         switch(p.length) {
 224             case 3:
 225                  ap = new AAFPermission(null, p[0],p[1],p[2]);
 226                  break;
 227             case 4:
 228                 ap = new AAFPermission(p[0],p[1],p[2],p[3]);
 229                 break;
 230             default:
 231                 return Result.err(Result.ERR_BadData,"Invalid Perm String");
 232         }
 233         if (AAF_CM.aafLurPerm.fish(trans.getUserPrincipal(), ap)) {
 234             resp.setContentType(voidResp);
 235             resp.getOutputStream().write(0);
 236             return Result.ok();
 237         } else {
 238             return Result.err(Result.ERR_Denied,"%s does not have %s",trans.user(),ap.getKey());
 239         }
 240     }
 241
 242     /* (non-Javadoc)
 243      * @see com.att.auth.certman.facade.Facade#requestCert(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
 244      */
 245     @Override
 246     public Result<Void> requestCert(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, CA ca) {
 247         TimeTaken tt = trans.start(REQUEST_CERT, Env.SUB|Env.ALWAYS);
 248         String wt;
 249         boolean withTrust=(wt=req.getParameter("withTrust"))!=null || TRUE.equalsIgnoreCase(wt);
 250         try {
 251             REQ request;
 252             try {
 253                 Data<REQ> rd = certRequestDF.newData().load(req.getInputStream());
 254                 request = rd.asObject();
 255             } catch (APIException e) {
 256                 trans.error().log("Invalid Input",IN,REQUEST_CERT);
 257                 return Result.err(Result.ERR_BadData,"Invalid Input");
 258             }
 259
 260             Result<CertResp> rcr = service.requestCert(trans,mapper.toReq(trans,request), ca);
 261             if (rcr.notOK()) {
 262                 return Result.err(rcr);
 263             }
 264
 265             Result<CERT> rc = mapper.toCert(trans, rcr, withTrust);
 266             if (rc.status == OK) {
 267                 RosettaData<CERT> data = certDF.newData(trans).load(rc.value);
 268                 data.to(resp.getOutputStream());
 269
 270                 setContentType(resp, certDF.getOutType());
 271                 return Result.ok();
 272             }
 273             return Result.err(rc);
 274
 275         } catch (Exception e) {
 276             trans.error().log(e,IN,REQUEST_CERT);
 277             return Result.err(e);
 278         } finally {
 279             tt.done();
 280         }
 281     }
 282
 283     /* (non-Javadoc)
 284      * @see org.onap.aaf.auth.cm.facade.Facade#requestPersonalCert(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, boolean)
 285      */
 286     @Override
 287     public Result<Void> requestPersonalCert(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, CA ca) {
 288         return Result.err(Result.ERR_NotImplemented, "not implemented yet");
 289     }
 290
 291     @Override
 292     public Result<Void> renewCert(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, boolean withTrust) {
 293         TimeTaken tt = trans.start(RENEW_CERT, Env.SUB|Env.ALWAYS);
 294         try {
 295             REQ request;
 296             try {
 297                 Data<REQ> rd = certRenewDF.newData().load(req.getInputStream());
 298                 request = rd.asObject();
 299             } catch (APIException e) {
 300                 trans.error().log("Invalid Input",IN,RENEW_CERT);
 301                 return Result.err(Result.ERR_BadData,"Invalid Input");
 302             }
 303
 304             Result<CertResp> rcr = service.renewCert(trans,mapper.toRenew(trans,request));
 305             Result<CERT> rc = mapper.toCert(trans, rcr, withTrust);
 306
 307             if (rc.status == OK) {
 308                 RosettaData<CERT> data = certDF.newData(trans).load(rc.value);
 309                 data.to(resp.getOutputStream());
 310
 311                 setContentType(resp, certDF.getOutType());
 312                 return Result.ok();
 313             }
 314             return Result.err(rc);
 315         } catch (Exception e) {
 316             trans.error().log(e,IN,RENEW_CERT);
 317             return Result.err(e);
 318         } finally {
 319             tt.done();
 320         }
 321
 322     }
 323
 324     @Override
 325     public Result<Void> dropCert(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
 326         TimeTaken tt = trans.start(DROP_CERT, Env.SUB|Env.ALWAYS);
 327         try {
 328             REQ request;
 329             try {
 330                 Data<REQ> rd = certDropDF.newData().load(req.getInputStream());
 331                 request = rd.asObject();
 332             } catch (APIException e) {
 333                 trans.error().log("Invalid Input",IN,DROP_CERT);
 334                 return Result.err(Result.ERR_BadData,"Invalid Input");
 335             }
 336
 337             Result<Void> rv = service.dropCert(trans,mapper.toDrop(trans, request));
 338             if (rv.status == OK) {
 339                 setContentType(resp, certRequestDF.getOutType());
 340                 return Result.ok();
 341             }
 342             return Result.err(rv);
 343         } catch (Exception e) {
 344             trans.error().log(e,IN,DROP_CERT);
 345             return Result.err(e);
 346         } finally {
 347             tt.done();
 348         }
 349     }
 350
 351     /* (non-Javadoc)
 352      * @see org.onap.aaf.auth.cm.facade.Facade#readCertsByMechID(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
 353      */
 354     @Override
 355     public Result<Void> readCertsByMechID(AuthzTrans trans, HttpServletResponse resp, String mechID) {
 356         TimeTaken tt = trans.start(READ_CERTS_MECHID, Env.SUB|Env.ALWAYS);
 357         try {
 358             Result<CERT> rc = mapper.toCert(trans, service.readCertsByMechID(trans,mechID));
 359             if (rc.status == OK) {
 360                 RosettaData<CERT> data = certDF.newData(trans).load(rc.value);
 361                 data.to(resp.getOutputStream());
 362
 363                 setContentType(resp, certDF.getOutType());
 364                 return Result.ok();
 365             }
 366             return Result.err(rc);
 367         } catch (Exception e) {
 368             trans.error().log(e,IN,READ_CERTS_MECHID);
 369             return Result.err(e);
 370         } finally {
 371             tt.done();
 372         }
 373     }
 374
 375     ////////////////////////////
 376     // Artifacts
 377     ////////////////////////////
 378     @Override
 379     public Result<Void> createArtifacts(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
 380         TimeTaken tt = trans.start(CREATE_ARTIFACTS, Env.SUB);
 381         try {
 382             ARTIFACTS arti;
 383             try {
 384                 Data<ARTIFACTS> rd = artiDF.newData().load(req.getInputStream());
 385                 arti = rd.asObject();
 386             } catch (APIException e) {
 387                 trans.error().log("Invalid Input",IN,CREATE_ARTIFACTS);
 388                 return Result.err(Result.ERR_BadData,"Invalid Input");
 389             }
 390
 391             return service.createArtifact(trans,mapper.toArtifact(trans,arti));
 392         } catch (Exception e) {
 393
 394             trans.error().log(e,IN,CREATE_ARTIFACTS);
 395             return Result.err(e);
 396         } finally {
 397             tt.done();
 398         }
 399     }
 400
 401     @Override
 402     public Result<Void> readArtifacts(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
 403         TimeTaken tt = trans.start(READ_ARTIFACTS, Env.SUB);
 404         try {
 405             String mechid = req.getParameter("mechid");
 406             String machine = req.getParameter("machine");
 407             String ns = req.getParameter("ns");
 408
 409             Result<ARTIFACTS> ra;
 410             if ( machine !=null && mechid == null) {
 411                 ra = mapper.fromArtifacts(service.readArtifactsByMachine(trans, machine));
 412             } else if (mechid!=null && machine==null) {
 413                 ra = mapper.fromArtifacts(service.readArtifactsByMechID(trans, mechid));
 414             } else if (mechid!=null && machine!=null) {
 415                 ArtiDAO.Data add = new ArtiDAO.Data();
 416                 add.mechid = mechid;
 417                 add.machine = machine;
 418                 add.ns = ns;
 419                 ra = mapper.fromArtifacts(service.readArtifacts(trans,add));
 420             } else if (ns!=null) {
 421                 ra = mapper.fromArtifacts(service.readArtifactsByNs(trans, ns));
 422             } else {
 423                 ra = Result.err(Status.ERR_BadData,"Invalid request inputs");
 424             }
 425
 426             if (ra.isOK()) {
 427                 RosettaData<ARTIFACTS> data = artiDF.newData(trans).load(ra.value);
 428                 data.to(resp.getOutputStream());
 429                 setContentType(resp,artiDF.getOutType());
 430                 return Result.ok();
 431             } else {
 432                 return Result.err(ra);
 433             }
 434
 435         } catch (Exception e) {
 436             trans.error().log(e,IN,READ_ARTIFACTS);
 437             return Result.err(e);
 438         } finally {
 439             tt.done();
 440         }
 441     }
 442
 443     @Override
 444     public Result<Void> readArtifacts(AuthzTrans trans, HttpServletResponse resp, String mechid, String machine) {
 445         TimeTaken tt = trans.start(READ_ARTIFACTS, Env.SUB);
 446         try {
 447             ArtiDAO.Data add = new ArtiDAO.Data();
 448             add.mechid = mechid;
 449             add.machine = machine;
 450             Result<ARTIFACTS> ra = mapper.fromArtifacts(service.readArtifacts(trans,add));
 451             if (ra.isOK()) {
 452                 RosettaData<ARTIFACTS> data = artiDF.newData(trans).load(ra.value);
 453                 data.to(resp.getOutputStream());
 454                 setContentType(resp,artiDF.getOutType());
 455                 return Result.ok();
 456             } else {
 457                 return Result.err(ra);
 458             }
 459         } catch (Exception e) {
 460             trans.error().log(e,IN,READ_ARTIFACTS);
 461             return Result.err(e);
 462         } finally {
 463             tt.done();
 464         }
 465     }
 466
 467
 468     @Override
 469     public Result<Void> updateArtifacts(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
 470         TimeTaken tt = trans.start(UPDATE_ARTIFACTS, Env.SUB);
 471         try {
 472             ARTIFACTS arti;
 473             try {
 474                 Data<ARTIFACTS> rd = artiDF.newData().load(req.getInputStream());
 475                 arti = rd.asObject();
 476             } catch (APIException e) {
 477                 trans.error().log("Invalid Input",IN,UPDATE_ARTIFACTS);
 478                 return Result.err(Result.ERR_BadData,"Invalid Input");
 479             }
 480
 481             return service.updateArtifact(trans,mapper.toArtifact(trans,arti));
 482         } catch (Exception e) {
 483             trans.error().log(e,IN,UPDATE_ARTIFACTS);
 484             return Result.err(e);
 485         } finally {
 486             tt.done();
 487         }
 488     }
 489
 490     @Override
 491     public Result<Void> deleteArtifacts(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
 492         TimeTaken tt = trans.start(DELETE_ARTIFACTS, Env.SUB);
 493         try {
 494             ARTIFACTS arti;
 495             try {
 496                 Data<ARTIFACTS> rd = artiDF.newData().load(req.getInputStream());
 497                 arti = rd.asObject();
 498             } catch (APIException e) {
 499                 trans.error().log("Invalid Input",IN,DELETE_ARTIFACTS);
 500                 return Result.err(Result.ERR_BadData,"Invalid Input");
 501             }
 502
 503             Result<Void> rv = service.deleteArtifact(trans,mapper.toArtifact(trans,arti));
 504             if (rv.status == OK) {
 505                 setContentType(resp, artiDF.getOutType());
 506             }
 507             return rv;
 508         } catch (Exception e) {
 509             trans.error().log(e,IN,DELETE_ARTIFACTS);
 510             return Result.err(e);
 511         } finally {
 512             tt.done();
 513         }
 514     }
 515
 516     @Override
 517     public Result<Void> deleteArtifacts(AuthzTrans trans, HttpServletResponse resp, String mechid, String machine) {
 518         TimeTaken tt = trans.start(DELETE_ARTIFACTS, Env.SUB);
 519         try {
 520             Result<Void> rv = service.deleteArtifact(trans, mechid, machine);
 521             if (rv.status == OK) {
 522                 setContentType(resp, artiDF.getOutType());
 523             }
 524             return rv;
 525         } catch (Exception e) {
 526             trans.error().log(e,IN,DELETE_ARTIFACTS);
 527             return Result.err(e);
 528         } finally {
 529             tt.done();
 530         }
 531     }
 532
 533
 534 }