adapters/mso-openstack-adapters/src/main/java/org/onap/so/adapters/tenant/TenantAdapterRest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP - SO
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * Copyright (C) 2017 Huawei Technologies Co., Ltd. All rights reserved.
   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 package org.onap.so.adapters.tenant;
  23
  24
  25 import java.util.Map;
  26
  27 import javax.servlet.http.HttpServletResponse;
  28 import javax.ws.rs.Consumes;
  29 import javax.ws.rs.DELETE;
  30 import javax.ws.rs.GET;
  31 import javax.ws.rs.POST;
  32 import javax.ws.rs.Path;
  33 import javax.ws.rs.PathParam;
  34 import javax.ws.rs.Produces;
  35 import javax.ws.rs.QueryParam;
  36 import javax.ws.rs.core.MediaType;
  37 import javax.ws.rs.core.Response;
  38 import javax.xml.ws.Holder;
  39
  40 import org.onap.so.adapters.tenant.exceptions.TenantAlreadyExists;
  41 import org.onap.so.adapters.tenant.exceptions.TenantException;
  42 import org.onap.so.adapters.tenantrest.CreateTenantError;
  43 import org.onap.so.adapters.tenantrest.CreateTenantRequest;
  44 import org.onap.so.adapters.tenantrest.CreateTenantResponse;
  45 import org.onap.so.adapters.tenantrest.DeleteTenantError;
  46 import org.onap.so.adapters.tenantrest.DeleteTenantRequest;
  47 import org.onap.so.adapters.tenantrest.DeleteTenantResponse;
  48 import org.onap.so.adapters.tenantrest.QueryTenantError;
  49 import org.onap.so.adapters.tenantrest.QueryTenantResponse;
  50 import org.onap.so.adapters.tenantrest.RollbackTenantError;
  51 import org.onap.so.adapters.tenantrest.RollbackTenantRequest;
  52 import org.onap.so.adapters.tenantrest.RollbackTenantResponse;
  53 import org.onap.so.adapters.tenantrest.TenantRollback;
  54 import org.onap.so.logger.MsoLogger;
  55 import org.onap.so.openstack.beans.MsoTenant;
  56 import org.onap.so.openstack.exceptions.MsoExceptionCategory;
  57 import org.springframework.beans.factory.annotation.Autowired;
  58 import org.springframework.stereotype.Component;
  59
  60 import io.swagger.annotations.Api;
  61 import io.swagger.annotations.ApiOperation;
  62 import io.swagger.annotations.ApiParam;
  63 import io.swagger.annotations.ApiResponse;
  64 import io.swagger.annotations.ApiResponses;
  65
  66 /**
  67  * This class services calls to the REST interface for Tenants (http://host:port/vnfs/rest/v1/tenants)
  68  * Both XML and JSON can be produced/consumed.  Set Accept: and Content-Type: headers appropriately.  XML is the default.
  69  */
  70 @Path("/v1/tenants")
  71 @Api(value = "/v1/tenants", description = "root of tenant adapters restful web service")
  72 @Component
  73 public class TenantAdapterRest {
  74         private static MsoLogger LOGGER = MsoLogger.getMsoLogger (MsoLogger.Catalog.RA, TenantAdapterRest.class);
  75
  76         //RAA? No logging in wrappers
  77         @Autowired
  78         private MsoTenantAdapterImpl tenantImpl;
  79
  80
  81
  82         /*
  83         URL:
  84         EP: http://host:8080/tenants/rest
  85         Resource: v1/tenants
  86         REQ - metadata?
  87         {
  88         "cloudSiteId": "DAN",
  89         "tenantName": "RAA_1",
  90         "failIfExists": true,
  91         "msoRequest": {
  92         "requestId": "ra1",
  93         "serviceInstanceId": "sa1"
  94         }}
  95         RESP-
  96         {
  97    "cloudSiteId": "DAN",
  98    "tenantId": "128e10b9996d43a7874f19bbc4eb6749",
  99    "tenantCreated": true,
 100    "tenantRollback":    {
 101       "tenantId": "128e10b9996d43a7874f19bbc4eb6749",
 102       "cloudId": "DAN", // RAA? cloudId instead of cloudSiteId
 103       "tenantCreated": true,
 104       "msoRequest":       {
 105          "requestId": "ra1",
 106          "serviceInstanceId": "sa1"
 107       }
 108          }
 109         }
 110         */
 111         @POST
 112         @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 113         @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 114         @ApiOperation(value = "CreateTenant",
 115                                 response = Response.class,
 116                                 notes = "Creates a new tenant, CreateTenantRequest data is required")
 117         @ApiResponses({
 118                 @ApiResponse(code = 200, message = "tenant has been successfully created"),
 119                 @ApiResponse(code = 500, message = "create tenant failed") })
 120         public Response createTenant(
 121                         @ApiParam(value = "details of tenant being created", required = true)
 122                         CreateTenantRequest req) {
 123                 LOGGER.debug("createTenant enter: " + req.toJsonString());
 124
 125                 String newTenantId = null;
 126                 TenantRollback tenantRollback = new TenantRollback ();
 127
 128                 try {
 129                         Holder<String> htenant = new Holder<>();
 130                         Holder<TenantRollback> hrollback = new Holder<>();
 131                         MsoTenantAdapter impl = tenantImpl;
 132                     impl.createTenant(
 133                         req.getCloudSiteId(),
 134                         req.getTenantName(),
 135                         req.getMetadata(),
 136                         req.getFailIfExists(),
 137                 req.getBackout(),
 138                 req.getMsoRequest(),
 139                 htenant,
 140                 hrollback);
 141                     newTenantId = htenant.value;
 142                     tenantRollback = hrollback.value;
 143 //                      TenantAdapterCore TAImpl = new TenantAdapterCore();
 144 //                      newTenantId =  TAImpl.createTenant (req.getCloudSiteId(),
 145 //                                                                                              req.getTenantName(),
 146 //                                                                                              req.getFailIfExists(),
 147 //                                                                                              req.getBackout(),
 148 //                                                                                              req.getMetadata(),
 149 //                                                                                              req.getMsoRequest(),
 150 //                                                                                              tenantRollback);
 151                 }
 152                 catch (TenantAlreadyExists tae) {
 153                         LOGGER.debug("Exception :",tae);
 154                         CreateTenantError exc = new CreateTenantError(tae.getMessage(), tae.getFaultInfo().getCategory(), Boolean.TRUE);
 155                         return Response.status(HttpServletResponse.SC_NOT_IMPLEMENTED).entity(exc).build();
 156                 }
 157                 catch (TenantException te) {
 158                         LOGGER.debug("Exception :",te);
 159                         CreateTenantError exc = new CreateTenantError(te.getFaultInfo().getMessage(), te.getFaultInfo().getCategory(), Boolean.TRUE);
 160                         return Response.status(HttpServletResponse.SC_INTERNAL_SERVER_ERROR).entity(exc).build();
 161                 }
 162                 catch (Exception e) {
 163                         LOGGER.debug("Exception :",e);
 164                         CreateTenantError exc = new CreateTenantError(e.getMessage(), MsoExceptionCategory.INTERNAL, Boolean.TRUE);
 165                         return Response.status(HttpServletResponse.SC_INTERNAL_SERVER_ERROR).entity(exc).build();
 166                 }
 167
 168                 CreateTenantResponse resp = new CreateTenantResponse (req.getCloudSiteId(), newTenantId, tenantRollback.getTenantCreated(), tenantRollback);
 169                 return Response.status(HttpServletResponse.SC_OK).entity(resp).build();
 170         }
 171
 172         /*
 173         URL:
 174         http://host:8080/tenants/rest
 175         Resource: v1/tenant/tennatId
 176         REQ:
 177         {"cloudSiteId": "DAN",
 178         "tenantId": "ca84cd3d3df44272845da554656b3ace",
 179         "msoRequest": {
 180         "requestId": "ra1",
 181         "serviceInstanceId": "sa1"
 182         }
 183         }
 184         RESP:
 185         {"tenantDeleted": true}
 186          */
 187         @DELETE
 188         @Path("{tenantId}")
 189         @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 190         @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 191         @ApiOperation(value = "DeleteTenant",
 192                 response = Response.class,
 193                 notes = "Delete an existing tenant")
 194         @ApiResponses({
 195                 @ApiResponse(code = 200, message = "tenant has been successfully deleted"),
 196                 @ApiResponse(code = 500, message = "delete tenant failed") })
 197         public Response deleteTenant(
 198                 @ApiParam(value = "tenantId of tenant being deleted", required = true)
 199                 @PathParam("tenantId") String tenantId,
 200                 @ApiParam(value = "DeleteTenantRequest object containing additional information of tenant being deleted", required = false)
 201                 DeleteTenantRequest req)
 202         {
 203                 boolean tenantDeleted = false;
 204
 205                 try {
 206                         Holder<Boolean> deleted = new Holder<>();
 207                         MsoTenantAdapter impl = tenantImpl;
 208                     impl.deleteTenant(
 209                         req.getCloudSiteId(),
 210                         req.getTenantId(),
 211                         req.getMsoRequest(),
 212                         deleted);
 213                     tenantDeleted = deleted.value;
 214                 }
 215                 catch (TenantException te) {
 216                         LOGGER.debug("Exception :",te);
 217                         DeleteTenantError exc = new DeleteTenantError(te.getFaultInfo().getMessage(), te.getFaultInfo().getCategory(), Boolean.TRUE);
 218                         return Response.status(HttpServletResponse.SC_INTERNAL_SERVER_ERROR).entity(exc).build();
 219                 }
 220                 catch (Exception e) {
 221                         LOGGER.debug("Exception :",e);
 222                         DeleteTenantError exc = new DeleteTenantError(e.getMessage(), MsoExceptionCategory.INTERNAL, Boolean.TRUE);
 223                         return Response.status(HttpServletResponse.SC_INTERNAL_SERVER_ERROR).entity(exc).build();
 224                 }
 225                 DeleteTenantResponse resp = new DeleteTenantResponse();
 226                 resp.setTenantDeleted(tenantDeleted);
 227                 return Response.status(HttpServletResponse.SC_OK).entity(resp).build();
 228         }
 229
 230         /*
 231         URL
 232         EP://http://host:8080/tenants/rest
 233         Resource: /v1/tenants
 234         Params:?tenantNameOrId=RAA_1&cloudSiteId=DAN
 235         RESP
 236         {
 237                    "tenantId": "214b428a1f554c02935e66330f6a5409",
 238                    "tenantName": "RAA_1",
 239                    "metadata": {}
 240         }
 241         */
 242         @GET
 243         @Path("{tenantId}")
 244         @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 245         @ApiOperation(value = "QueryTenant",
 246                 response = Response.class,
 247                 notes = "Query an existing tenant")
 248         @ApiResponses({
 249                 @ApiResponse(code = 200, message = "tenant has been successfully queried"),
 250                 @ApiResponse(code = 500, message = "query tenant failed") })
 251         public Response queryTenant(
 252                         @ApiParam(value = "tenantId", required = true)
 253                         @PathParam("tenantId") String tenantId,
 254 //                      @QueryParam("tenantNameOrId") String tenantNameOrId, //RAA? diff from doc
 255                         @ApiParam(value = "cloudSiteId", required = true)
 256                         @QueryParam("cloudSiteId") String cloudSiteId,
 257                         @ApiParam(value = "msoRequest.requestId", required = true)
 258                         @QueryParam("msoRequest.requestId") String requestId,
 259                         @ApiParam(value = "msoRequest.serviceInstanceId", required = true)
 260                         @QueryParam("msoRequest.serviceInstanceId") String serviceInstanceId)
 261         {
 262                 MsoTenant tenant = null;
 263                 try {
 264                         Holder<String> htenant = new Holder<>();
 265                         Holder<String> tenantName = new Holder<>();
 266                         Holder<Map<String,String>> metadata = new Holder<>();
 267                         MsoTenantAdapter impl = tenantImpl;
 268                     impl.queryTenant(
 269                         cloudSiteId,
 270                         tenantId,
 271                         null,
 272                         htenant,
 273                         tenantName,
 274                         metadata
 275                         );
 276                     tenant = new MsoTenant(htenant.value, tenantName.value, metadata.value);
 277 //                      TenantAdapterCore TAImpl = new TenantAdapterCore();
 278 //                      MsoRequest msoReq = new MsoRequest();
 279 //                      tenant = TAImpl.queryTenant (cloudSiteId, tenantId, msoReq);
 280                 }
 281                 catch (TenantException te) {
 282                         LOGGER.debug("Exception :",te);
 283                         QueryTenantError exc = new QueryTenantError(te.getFaultInfo().getMessage(), te.getFaultInfo().getCategory());
 284                         return Response.status(HttpServletResponse.SC_INTERNAL_SERVER_ERROR).entity(exc).build();
 285                 }
 286                 catch (Exception e) {
 287                         LOGGER.debug("Exception :",e);
 288                         QueryTenantError exc = new QueryTenantError(e.getMessage(), MsoExceptionCategory.INTERNAL);
 289                         return Response.status(HttpServletResponse.SC_INTERNAL_SERVER_ERROR).entity(exc).build();
 290                 }
 291                 QueryTenantResponse resp = new QueryTenantResponse(tenant.getTenantId(), tenant.getTenantName(), tenant.getMetadata());
 292                 return Response.status(HttpServletResponse.SC_OK).entity(resp).build();
 293         }
 294
 295         /*
 296         URL
 297         EP: //http://host:8080/tenants/rest
 298         Resource: /v1/tenants/rollback
 299         REQ
 300         {"cloudSiteId": "DAN",
 301         "tenantId": "f58abb05041d4ff384d4d22d1ccd2a6c",
 302         "msoRequest": {
 303         "requestId": "ra1",
 304         "serviceInstanceId": "sa1"
 305         }
 306         }
 307         RESP:
 308         {"tenantDeleted": true}
 309          */
 310         @DELETE
 311         @Path("")
 312         @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 313         @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 314         @ApiOperation(value = "RollbackTenant",
 315                 response = Response.class,
 316                 notes = "Rollback an existing tenant")
 317         @ApiResponses({
 318                 @ApiResponse(code = 200, message = "tenant has been successfully rolledback"),
 319                 @ApiResponse(code = 500, message = "rollback tenant failed") })
 320         public Response rollbackTenant(
 321                 @ApiParam(value = "rollback, command action", required = true)
 322                 @QueryParam("rollback") String action, // WTF?
 323                 @ApiParam(value = "RollbackTenantRequest", required = true)
 324                 RollbackTenantRequest req)
 325         {
 326                 try {
 327                         MsoTenantAdapter impl = tenantImpl;
 328                     impl.rollbackTenant(req.getTenantRollback());
 329                 }
 330                 catch (TenantException te) {
 331                         LOGGER.debug("Exception :",te);
 332                         RollbackTenantError exc = new RollbackTenantError(te.getFaultInfo().getMessage(), te.getFaultInfo().getCategory(), Boolean.TRUE);
 333                         return Response.status(HttpServletResponse.SC_INTERNAL_SERVER_ERROR).entity(exc).build();
 334                 }
 335                 catch (Exception e) {
 336                         LOGGER.debug("Exception :",e);
 337                         RollbackTenantError exc = new RollbackTenantError(e.getMessage(), MsoExceptionCategory.INTERNAL, Boolean.TRUE);
 338                         return Response.status(HttpServletResponse.SC_INTERNAL_SERVER_ERROR).entity(exc).build();
 339                 }
 340
 341                 RollbackTenantResponse resp = new RollbackTenantResponse ();
 342                 resp.setTenantRolledback(req != null);
 343                 return Response.status(HttpServletResponse.SC_OK).entity(resp).build();
 344         }
 345 }