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  * ===========================================================================
   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  */
  21
  22 package org.onap.aaf.auth.cm.facade;
  23
  24 import static org.onap.aaf.auth.layer.Result.ERR_ActionNotCompleted;
  25 import static org.onap.aaf.auth.layer.Result.ERR_BadData;
  26 import static org.onap.aaf.auth.layer.Result.ERR_ConflictAlreadyExists;
  27 import static org.onap.aaf.auth.layer.Result.ERR_Denied;
  28 import static org.onap.aaf.auth.layer.Result.ERR_NotFound;
  29 import static org.onap.aaf.auth.layer.Result.ERR_NotImplemented;
  30 import static org.onap.aaf.auth.layer.Result.ERR_Policy;
  31 import static org.onap.aaf.auth.layer.Result.ERR_Security;
  32 import static org.onap.aaf.auth.layer.Result.OK;
  33
  34 import java.io.IOException;
  35
  36 import javax.servlet.http.HttpServletRequest;
  37 import javax.servlet.http.HttpServletResponse;
  38
  39 import org.onap.aaf.auth.cm.AAF_CM;
  40 import org.onap.aaf.auth.cm.ca.CA;
  41 import org.onap.aaf.auth.cm.data.CertResp;
  42 import org.onap.aaf.auth.cm.mapper.Mapper;
  43 import org.onap.aaf.auth.cm.mapper.Mapper.API;
  44 import org.onap.aaf.auth.cm.service.CMService;
  45 import org.onap.aaf.auth.dao.cass.ArtiDAO;
  46 import org.onap.aaf.auth.dao.cass.Status;
  47 import org.onap.aaf.auth.env.AuthzEnv;
  48 import org.onap.aaf.auth.env.AuthzTrans;
  49 import org.onap.aaf.auth.layer.Result;
  50 import org.onap.aaf.cadi.aaf.AAFPermission;
  51 import org.onap.aaf.misc.env.APIException;
  52 import org.onap.aaf.misc.env.Data;
  53 import org.onap.aaf.misc.env.Env;
  54 import org.onap.aaf.misc.env.TimeTaken;
  55 import org.onap.aaf.misc.env.util.Split;
  56 import org.onap.aaf.misc.rosetta.env.RosettaDF;
  57 import org.onap.aaf.misc.rosetta.env.RosettaData;
  58
  59 /**
  60  * AuthzFacade
  61  *
  62  * This Service Facade encapsulates the essence of the API Service can do, and provides
  63  * a single created object for elements such as RosettaDF.
  64  *
  65  * The Responsibilities of this class are to:
  66  * 1) Interact with the Service Implementation (which might be supported by various kinds of Backend Storage)
  67  * 2) Validate incoming data (if applicable)
  68  * 3) Convert the Service response into the right Format, and mark the Content Type
  69  *         a) In the future, we may support multiple Response Formats, aka JSON or XML, based on User Request.
  70  * 4) Log Service info, warnings and exceptions as necessary
  71  * 5) When asked by the API layer, this will create and write Error content to the OutputStream
  72  *
  73  * Note: This Class does NOT set the HTTP Status Code.  That is up to the API layer, so that it can be
  74  * clearly coordinated with the API Documentation
  75  *
  76  * @author Jonathan
  77  *
  78  */
  79 public abstract class FacadeImpl<REQ,CERT,ARTIFACTS,ERROR> extends org.onap.aaf.auth.layer.FacadeImpl implements Facade<REQ,CERT,ARTIFACTS,ERROR>
  80     {
  81     private static final String TRUE = "TRUE";
  82     private static final String REQUEST_CERT = "Request New Certificate";
  83     private static final String RENEW_CERT = "Renew Certificate";
  84     private static final String DROP_CERT = "Drop Certificate";
  85     private static final String READ_CERTS_MECHID = "Read Certificates by MechID";
  86     private static final String CREATE_ARTIFACTS = "Create Deployment Artifact";
  87     private static final String READ_ARTIFACTS = "Read Deployment Artifact";
  88     private static final String UPDATE_ARTIFACTS = "Update Deployment Artifact";
  89     private static final String DELETE_ARTIFACTS = "Delete Deployment Artifact";
  90
  91     private CMService service;
  92
  93     private final RosettaDF<ERROR>         errDF;
  94     private final RosettaDF<REQ>         certRequestDF, certRenewDF, certDropDF;
  95     private final RosettaDF<CERT>        certDF;
  96     private final RosettaDF<ARTIFACTS>    artiDF;
  97     private Mapper<REQ, CERT, ARTIFACTS, ERROR>     mapper;
  98 //    private Slot sCertAuth;
  99     private AAF_CM certman;
 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         this.certman = certman;
 109         AuthzEnv env = certman.env;
 110         //TODO: Gabe [JUnit] Static issue, talk to Jonathan
 111         (errDF                 = env.newDataFactory(mapper.getClass(API.ERROR))).in(dataType).out(dataType);
 112         (certRequestDF         = env.newDataFactory(mapper.getClass(API.CERT_REQ))).in(dataType).out(dataType);
 113         (certRenewDF         = env.newDataFactory(mapper.getClass(API.CERT_RENEW))).in(dataType).out(dataType);
 114         (certDropDF         = env.newDataFactory(mapper.getClass(API.CERT_DROP))).in(dataType).out(dataType);
 115         (certDF             = env.newDataFactory(mapper.getClass(API.CERT))).in(dataType).out(dataType);
 116         (artiDF             = env.newDataFactory(mapper.getClass(API.ARTIFACTS))).in(dataType).out(dataType);
 117 //        sCertAuth = env.slot(API_Cert.CERT_AUTH);
 118         if(artiDF.getOutType().name().contains("xml")) {
 119             voidResp = "application/Void+xml;charset=utf-8;version=1.0,application/xml;version=1.0,*/*";
 120         } else {
 121             voidResp = "application/Void+json;charset=utf-8;version=1.0,application/json;version=1.0,*/*";
 122         }
 123     }
 124
 125     public Mapper<REQ,CERT,ARTIFACTS,ERROR> mapper() {
 126         return mapper;
 127     }
 128
 129     /* (non-Javadoc)
 130      * @see com.att.authz.facade.AuthzFacade#error(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, int)
 131      *
 132      * Note: Conforms to AT&T TSS RESTful Error Structure
 133      */
 134     @Override
 135     public void error(AuthzTrans trans, HttpServletResponse response, Result<?> result) {
 136         error(trans, response, result.status,
 137                 result.details==null?"":result.details.trim(),
 138                 result.variables==null?new String[0]:result.variables);
 139     }
 140
 141     @Override
 142     public void error(AuthzTrans trans, HttpServletResponse response, int status, final String _msg, final String ... _detail) {
 143         String msgId;
 144         String prefix;
 145         boolean hidemsg=false;
 146         switch(status) {
 147             case 202:
 148             case ERR_ActionNotCompleted:
 149                 msgId = "SVC1202";
 150                 prefix = "Accepted, Action not complete";
 151                 response.setStatus(/*httpstatus=*/202);
 152                 break;
 153
 154             case 403:
 155             case ERR_Policy:
 156             case ERR_Security:
 157             case ERR_Denied:
 158                 msgId = "SVC1403";
 159                 prefix = "Forbidden";
 160                 response.setStatus(/*httpstatus=*/403);
 161                 break;
 162
 163             case 404:
 164             case ERR_NotFound:
 165                 msgId = "SVC1404";
 166                 prefix = "Not Found";
 167                 response.setStatus(/*httpstatus=*/404);
 168                 break;
 169
 170             case 406:
 171             case ERR_BadData:
 172                 msgId="SVC1406";
 173                 prefix = "Not Acceptable";
 174                 response.setStatus(/*httpstatus=*/406);
 175                 break;
 176
 177             case 409:
 178             case ERR_ConflictAlreadyExists:
 179                 msgId = "SVC1409";
 180                 prefix = "Conflict Already Exists";
 181                 response.setStatus(/*httpstatus=*/409);
 182                 break;
 183
 184             case 501:
 185             case ERR_NotImplemented:
 186                 msgId = "SVC1501";
 187                 prefix = "Not Implemented";
 188                 response.setStatus(/*httpstatus=*/501);
 189                 break;
 190
 191
 192             default:
 193                 msgId = "SVC1500";
 194                 prefix = "General Service Error";
 195                 response.setStatus(/*httpstatus=*/500);
 196                 hidemsg=true;
 197                 break;
 198         }
 199
 200         try {
 201             StringBuilder holder = new StringBuilder();
 202             ERROR em = mapper().errorFromMessage(holder, msgId,prefix + ": " + _msg,_detail);
 203             trans.checkpoint(
 204                     "ErrResp [" +
 205                     msgId +
 206                     "] " +
 207                     holder.toString(),
 208                     Env.ALWAYS);
 209             if(hidemsg) {
 210                 holder.setLength(0);
 211                 em = mapper().errorFromMessage(holder, msgId, "Server had an issue processing this request");
 212             }
 213             errDF.newData(trans).load(em).to(response.getOutputStream());
 214
 215         } catch (Exception e) {
 216             trans.error().log(e,"unable to send response for",_msg);
 217         }
 218     }
 219
 220     @Override
 221     public Result<Void> check(AuthzTrans trans, HttpServletResponse resp, String perm) throws IOException {
 222         String[] p = Split.split('|',perm);
 223         AAFPermission ap;
 224         switch(p.length) {
 225             case 3:
 226                  ap = new AAFPermission(null, p[0],p[1],p[2]);
 227                  break;
 228             case 4:
 229                 ap = new AAFPermission(p[0],p[1],p[2],p[3]);
 230                 break;
 231             default:
 232                 return Result.err(Result.ERR_BadData,"Invalid Perm String");
 233         }
 234         if(certman.aafLurPerm.fish(trans.getUserPrincipal(), ap)) {
 235             resp.setContentType(voidResp);
 236             resp.getOutputStream().write(0);
 237             return Result.ok();
 238         } else {
 239             return Result.err(Result.ERR_Denied,"%s does not have %s",trans.user(),ap.getKey());
 240         }
 241     }
 242
 243     /* (non-Javadoc)
 244      * @see com.att.auth.certman.facade.Facade#requestCert(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
 245      */
 246     @Override
 247     public Result<Void> requestCert(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, CA ca) {
 248         TimeTaken tt = trans.start(REQUEST_CERT, Env.SUB|Env.ALWAYS);
 249         String wt;
 250         boolean withTrust=(wt=req.getParameter("withTrust"))!=null || TRUE.equalsIgnoreCase(wt);
 251         try {
 252             REQ request;
 253             try {
 254                 Data<REQ> rd = certRequestDF.newData().load(req.getInputStream());
 255                 request = rd.asObject();
 256             } catch(APIException e) {
 257                 trans.error().log("Invalid Input",IN,REQUEST_CERT);
 258                 return Result.err(Result.ERR_BadData,"Invalid Input");
 259             }
 260
 261             Result<CertResp> rcr = service.requestCert(trans,mapper.toReq(trans,request), ca);
 262             if(rcr.notOK()) {
 263                 return Result.err(rcr);
 264             }
 265
 266 //            CA certAuth = trans.get(sCertAuth,null);
 267             Result<CERT> rc = mapper.toCert(trans, rcr, withTrust);
 268             switch(rc.status) {
 269                 case OK:
 270                     RosettaData<CERT> data = certDF.newData(trans).load(rc.value);
 271                     data.to(resp.getOutputStream());
 272
 273                     setContentType(resp,certDF.getOutType());
 274                     return Result.ok();
 275                 default:
 276                     return Result.err(rc);
 277             }
 278
 279         } catch (Exception e) {
 280             trans.error().log(e,IN,REQUEST_CERT);
 281             return Result.err(e);
 282         } finally {
 283             tt.done();
 284         }
 285     }
 286
 287     /* (non-Javadoc)
 288      * @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)
 289      */
 290     @Override
 291     public Result<Void> requestPersonalCert(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, CA ca) {
 292         return Result.err(Result.ERR_NotImplemented,"not implemented yet");
 293 //        Result<CertResp> rcr = service.requestPersonalCert(trans,ca);
 294 //        if(rcr.notOK()) {
 295 //            return Result.err(rcr);
 296 //        } else {
 297 //            try {
 298 //                resp.setContentType("application/zip, application/octet-stream");
 299 //                ZipOutputStream zos = new ZipOutputStream(resp.getOutputStream());
 300 //                PrintStream ps = new PrintStream(zos);
 301 //                ZipEntry ze = new ZipEntry(trans.user()+".key");
 302 //                zos.putNextEntry(ze);
 303 //                ps.print(rcr.value.privateString());
 304 //                zos.closeEntry();
 305 //
 306 //                zos.putNextEntry(new ZipEntry(trans.user()+".crt"));
 307 //                ps.print(rcr.value.asCertString());
 308 //                zos.closeEntry();
 309 //
 310 //                String wt;
 311 //                if((wt=req.getParameter("withTrust"))!=null || TRUE.equalsIgnoreCase(wt)) {
 312 //                    zos.putNextEntry(new ZipEntry(trans.user()+".trustCrts"));
 313 //                    for(String s : ca.getTrustChain()) {
 314 //                        ps.println(s);
 315 //                    }
 316 //                    zos.closeEntry();
 317 //                }
 318 //
 319 //                boolean withJKS = (wt=req.getParameter("withJKS"))!=null || TRUE.equalsIgnoreCase(wt);
 320 //                if(withJKS) {
 321 //                    if(trans.getUserPrincipal() instanceof BasicPrincipal) {
 322 //                        char[] cap = new String(((BasicPrincipal)trans.getUserPrincipal()).getCred()).toCharArray();
 323 //                        KeyStore ks = keystore(trans, rcr.value, ca.getTrustChain(), trans.user(), cap);
 324 //                        zos.putNextEntry(new ZipEntry(trans.user()+".jks"));
 325 //                        ks.store(zos, cap);
 326 //                        zos.closeEntry();
 327 //                    }
 328 //                }
 329 //
 330 //                zos.putNextEntry(new ZipEntry("cert_deploy.sh"));
 331 //                ps.println("# Deploy Certificate to ~/.aaf");
 332 //                ps.println("if [ \"$1\" = \"\" ]; then echo \"sh deploy.sh <zipfile>\";exit; else chmod 700 $HOME/.aaf; fi");
 333 //                ps.println("chmod 600 $1");
 334 //                ps.println("if [ ! -e $HOME/.aaf ]; then mkdir -m 700 $HOME/.aaf; fi");
 335 //                ps.println("THE_PWD=`pwd`");
 336 //                ps.println("cd $HOME/.aaf");
 337 //                ps.println("echo \"Deploying to `pwd`\"");
 338 //                ps.println("jar -xvf $THE_PWD/$1 " + trans.user());
 339 //                ps.println("chmod 600 " + trans.user() + ".key");
 340 //                if(withJKS) {
 341 //                    ps.println("chmod 600 " + trans.user() + ".jks");
 342 //                }
 343 //                ps.println("cd $THE_PWD");
 344 //                ps.println("rm cert_deploy.sh");
 345 //                zos.closeEntry();
 346 //
 347 //
 348 //                zos.close();
 349 //
 350 //            } catch (IOException | KeyStoreException | CertificateException | APIException | CertException | NoSuchAlgorithmException e) {
 351 //                return Result.err(e);
 352 //            }
 353 //        }
 354 //
 355 //        return Result.ok();
 356     }
 357
 358 //    private KeyStore keystore(AuthzTrans trans, CertResp cr, String[] trustChain, String name, char[] cap) throws KeyStoreException, CertificateException, APIException, IOException, CertException, NoSuchAlgorithmException {
 359 //        KeyStore jks = KeyStore.getInstance("jks");
 360 //        jks.load(null, cap);
 361 //
 362 //        // Get the Cert(s)... Might include Trust store
 363 //        List<String> lcerts = new ArrayList<>();
 364 //        lcerts.add(cr.asCertString());
 365 //        for(String s : trustChain) {
 366 //            lcerts.add(s);
 367 //        }
 368 //
 369 //        Collection<? extends Certificate> certColl = Factory.toX509Certificate(lcerts);
 370 //        X509Certificate[] certs = new X509Certificate[certColl.size()];
 371 //        certColl.toArray(certs);
 372 //        KeyStore.ProtectionParameter protParam = new KeyStore.PasswordProtection(cap);
 373 //
 374 //        PrivateKey pk = Factory.toPrivateKey(trans, cr.privateString());
 375 //        KeyStore.PrivateKeyEntry pkEntry =
 376 //                new KeyStore.PrivateKeyEntry(pk, new Certificate[] {certs[0]});
 377 //        jks.setEntry(name, pkEntry, protParam);
 378 //
 379 //        int i=0;
 380 //        for(X509Certificate x509 : certs) {
 381 //            jks.setCertificateEntry("cert_"+ ++i, x509);
 382 //        }
 383 //        return jks;
 384 //    }
 385
 386     @Override
 387     public Result<Void> renewCert(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, boolean withTrust) {
 388         TimeTaken tt = trans.start(RENEW_CERT, Env.SUB|Env.ALWAYS);
 389         try {
 390             REQ request;
 391             try {
 392                 Data<REQ> rd = certRenewDF.newData().load(req.getInputStream());
 393                 request = rd.asObject();
 394             } catch(APIException e) {
 395                 trans.error().log("Invalid Input",IN,RENEW_CERT);
 396                 return Result.err(Result.ERR_BadData,"Invalid Input");
 397             }
 398
 399 //            String certAuth = trans.get(sCertAuth,null);
 400             Result<CertResp> rcr = service.renewCert(trans,mapper.toRenew(trans,request));
 401             Result<CERT> rc = mapper.toCert(trans, rcr, withTrust);
 402
 403             switch(rc.status) {
 404                 case OK:
 405                     RosettaData<CERT> data = certDF.newData(trans).load(rc.value);
 406                     data.to(resp.getOutputStream());
 407
 408                     setContentType(resp,certDF.getOutType());
 409                     return Result.ok();
 410                 default:
 411                     return Result.err(rc);
 412             }
 413         } catch (Exception e) {
 414             trans.error().log(e,IN,RENEW_CERT);
 415             return Result.err(e);
 416         } finally {
 417             tt.done();
 418         }
 419
 420     }
 421
 422     @Override
 423     public Result<Void> dropCert(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
 424         TimeTaken tt = trans.start(DROP_CERT, Env.SUB|Env.ALWAYS);
 425         try {
 426             REQ request;
 427             try {
 428                 Data<REQ> rd = certDropDF.newData().load(req.getInputStream());
 429                 request = rd.asObject();
 430             } catch(APIException e) {
 431                 trans.error().log("Invalid Input",IN,DROP_CERT);
 432                 return Result.err(Result.ERR_BadData,"Invalid Input");
 433             }
 434
 435             Result<Void> rv = service.dropCert(trans,mapper.toDrop(trans, request));
 436             switch(rv.status) {
 437                 case OK:
 438                     setContentType(resp,certRequestDF.getOutType());
 439                     return Result.ok();
 440                 default:
 441                     return Result.err(rv);
 442             }
 443         } catch (Exception e) {
 444             trans.error().log(e,IN,DROP_CERT);
 445             return Result.err(e);
 446         } finally {
 447             tt.done();
 448         }
 449     }
 450
 451     /* (non-Javadoc)
 452      * @see org.onap.aaf.auth.cm.facade.Facade#readCertsByMechID(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
 453      */
 454     @Override
 455     public Result<Void> readCertsByMechID(AuthzTrans trans, HttpServletResponse resp, String mechID) {
 456         TimeTaken tt = trans.start(READ_CERTS_MECHID, Env.SUB|Env.ALWAYS);
 457         try {
 458             Result<CERT> rc = mapper.toCert(trans, service.readCertsByMechID(trans,mechID));
 459             switch(rc.status) {
 460                 case OK:
 461                     RosettaData<CERT> data = certDF.newData(trans).load(rc.value);
 462                     data.to(resp.getOutputStream());
 463
 464                     setContentType(resp,certDF.getOutType());
 465                     return Result.ok();
 466                 default:
 467                     return Result.err(rc);
 468             }
 469         } catch (Exception e) {
 470             trans.error().log(e,IN,READ_CERTS_MECHID);
 471             return Result.err(e);
 472         } finally {
 473             tt.done();
 474         }
 475     }
 476
 477     ////////////////////////////
 478     // Artifacts
 479     ////////////////////////////
 480     @Override
 481     public Result<Void> createArtifacts(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
 482         TimeTaken tt = trans.start(CREATE_ARTIFACTS, Env.SUB);
 483         try {
 484             ARTIFACTS arti;
 485             try {
 486                 Data<ARTIFACTS> rd = artiDF.newData().load(req.getInputStream());
 487                 arti = rd.asObject();
 488             } catch(APIException e) {
 489                 trans.error().log("Invalid Input",IN,CREATE_ARTIFACTS);
 490                 return Result.err(Result.ERR_BadData,"Invalid Input");
 491             }
 492
 493             return service.createArtifact(trans,mapper.toArtifact(trans,arti));
 494         } catch (Exception e) {
 495
 496             trans.error().log(e,IN,CREATE_ARTIFACTS);
 497             return Result.err(e);
 498         } finally {
 499             tt.done();
 500         }
 501     }
 502
 503     @Override
 504     public Result<Void> readArtifacts(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
 505         TimeTaken tt = trans.start(READ_ARTIFACTS, Env.SUB);
 506         try {
 507             String mechid = req.getParameter("mechid");
 508             String machine = req.getParameter("machine");
 509             String ns = req.getParameter("ns");
 510
 511             Result<ARTIFACTS> ra;
 512             if( machine !=null && mechid == null) {
 513                 ra = mapper.fromArtifacts(service.readArtifactsByMachine(trans, machine));
 514             } else if(mechid!=null && machine==null) {
 515                 ra = mapper.fromArtifacts(service.readArtifactsByMechID(trans, mechid));
 516             } else if(mechid!=null && machine!=null) {
 517                 ArtiDAO.Data add = new ArtiDAO.Data();
 518                 add.mechid = mechid;
 519                 add.machine = machine;
 520                 add.ns = ns;
 521                 ra = mapper.fromArtifacts(service.readArtifacts(trans,add));
 522             } else if(ns!=null) {
 523                 ra = mapper.fromArtifacts(service.readArtifactsByNs(trans, ns));
 524             } else {
 525                 ra = Result.err(Status.ERR_BadData,"Invalid request inputs");
 526             }
 527
 528             if(ra.isOK()) {
 529                 RosettaData<ARTIFACTS> data = artiDF.newData(trans).load(ra.value);
 530                 data.to(resp.getOutputStream());
 531                 setContentType(resp,artiDF.getOutType());
 532                 return Result.ok();
 533             } else {
 534                 return Result.err(ra);
 535             }
 536
 537         } catch (Exception e) {
 538             trans.error().log(e,IN,READ_ARTIFACTS);
 539             return Result.err(e);
 540         } finally {
 541             tt.done();
 542         }
 543     }
 544
 545     @Override
 546     public Result<Void> readArtifacts(AuthzTrans trans, HttpServletResponse resp, String mechid, String machine) {
 547         TimeTaken tt = trans.start(READ_ARTIFACTS, Env.SUB);
 548         try {
 549             ArtiDAO.Data add = new ArtiDAO.Data();
 550             add.mechid = mechid;
 551             add.machine = machine;
 552             Result<ARTIFACTS> ra = mapper.fromArtifacts(service.readArtifacts(trans,add));
 553             if(ra.isOK()) {
 554                 RosettaData<ARTIFACTS> data = artiDF.newData(trans).load(ra.value);
 555                 data.to(resp.getOutputStream());
 556                 setContentType(resp,artiDF.getOutType());
 557                 return Result.ok();
 558             } else {
 559                 return Result.err(ra);
 560             }
 561         } catch (Exception e) {
 562             trans.error().log(e,IN,READ_ARTIFACTS);
 563             return Result.err(e);
 564         } finally {
 565             tt.done();
 566         }
 567     }
 568
 569
 570     @Override
 571     public Result<Void> updateArtifacts(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
 572         TimeTaken tt = trans.start(UPDATE_ARTIFACTS, Env.SUB);
 573         try {
 574             ARTIFACTS arti;
 575             try {
 576                 Data<ARTIFACTS> rd = artiDF.newData().load(req.getInputStream());
 577                 arti = rd.asObject();
 578             } catch(APIException e) {
 579                 trans.error().log("Invalid Input",IN,UPDATE_ARTIFACTS);
 580                 return Result.err(Result.ERR_BadData,"Invalid Input");
 581             }
 582
 583             return service.updateArtifact(trans,mapper.toArtifact(trans,arti));
 584         } catch (Exception e) {
 585             trans.error().log(e,IN,UPDATE_ARTIFACTS);
 586             return Result.err(e);
 587         } finally {
 588             tt.done();
 589         }
 590     }
 591
 592     @Override
 593     public Result<Void> deleteArtifacts(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
 594         TimeTaken tt = trans.start(DELETE_ARTIFACTS, Env.SUB);
 595         try {
 596             ARTIFACTS arti;
 597             try {
 598                 Data<ARTIFACTS> rd = artiDF.newData().load(req.getInputStream());
 599                 arti = rd.asObject();
 600             } catch(APIException e) {
 601                 trans.error().log("Invalid Input",IN,DELETE_ARTIFACTS);
 602                 return Result.err(Result.ERR_BadData,"Invalid Input");
 603             }
 604
 605             Result<Void> rv = service.deleteArtifact(trans,mapper.toArtifact(trans,arti));
 606             switch(rv.status) {
 607                 case OK:
 608                     setContentType(resp,artiDF.getOutType());
 609             }
 610             return rv;
 611         } catch (Exception e) {
 612             trans.error().log(e,IN,DELETE_ARTIFACTS);
 613             return Result.err(e);
 614         } finally {
 615             tt.done();
 616         }
 617     }
 618
 619     @Override
 620     public Result<Void> deleteArtifacts(AuthzTrans trans, HttpServletResponse resp, String mechid, String machine) {
 621         TimeTaken tt = trans.start(DELETE_ARTIFACTS, Env.SUB);
 622         try {
 623             Result<Void> rv = service.deleteArtifact(trans, mechid, machine);
 624             switch(rv.status) {
 625                 case OK:
 626                     setContentType(resp,artiDF.getOutType());
 627             }
 628             return rv;
 629         } catch (Exception e) {
 630             trans.error().log(e,IN,DELETE_ARTIFACTS);
 631             return Result.err(e);
 632         } finally {
 633             tt.done();
 634         }
 635     }
 636
 637
 638 }