gerrit.onap Code Review - vfc/nfvo/catalog.git/blob

   1 /**
   2  * Copyright 2016 [ZTE] and others.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.openo.commontosca.catalog.resources;
  17
  18 import io.swagger.annotations.Api;
  19 import io.swagger.annotations.ApiOperation;
  20 import io.swagger.annotations.ApiParam;
  21 import io.swagger.annotations.ApiResponse;
  22 import io.swagger.annotations.ApiResponses;
  23
  24 import javax.ws.rs.Consumes;
  25 import javax.ws.rs.GET;
  26 import javax.ws.rs.POST;
  27 import javax.ws.rs.Path;
  28 import javax.ws.rs.PathParam;
  29 import javax.ws.rs.Produces;
  30 import javax.ws.rs.QueryParam;
  31 import javax.ws.rs.core.MediaType;
  32 import javax.ws.rs.core.Response;
  33
  34 import org.eclipse.jetty.http.HttpStatus;
  35 import org.openo.commontosca.catalog.common.CommonErrorResponse;
  36 import org.openo.commontosca.catalog.db.exception.CatalogResourceException;
  37 import org.openo.commontosca.catalog.model.entity.ServiceTemplateOperation;
  38 import org.openo.commontosca.catalog.model.wrapper.ServiceTemplateWrapper;
  39 import org.openo.commontosca.catalog.common.ToolUtil;
  40 import org.openo.commontosca.catalog.model.entity.InputParameter;
  41 import org.openo.commontosca.catalog.model.entity.NodeTemplate;
  42 import org.openo.commontosca.catalog.model.entity.QueryRawDataCondition;
  43 import org.openo.commontosca.catalog.model.entity.ServiceTemplate;
  44 import org.openo.commontosca.catalog.model.entity.ServiceTemplateRawData;
  45 import org.openo.commontosca.catalog.model.parser.ToscaYamlModelParser;
  46 import org.slf4j.Logger;
  47 import org.slf4j.LoggerFactory;
  48
  49 import com.codahale.metrics.annotation.Timed;
  50
  51 /**
  52  * @author 10090474
  53  *
  54  */
  55 @Path("/servicetemplates")
  56 @Api(tags = {"Model Resource"})
  57 public class TemplateResource {
  58     private static final Logger logger = LoggerFactory.getLogger(TemplateResource.class);
  59
  60     /**
  61      * @param servicetemplateid
  62      * @return
  63      */
  64     @Path("/{servicetemplateid}")
  65     @GET
  66     @Consumes(MediaType.APPLICATION_JSON)
  67     @Produces(MediaType.APPLICATION_JSON)
  68     @ApiOperation(value = "Query service template by service template id",
  69             response = ServiceTemplate.class)
  70     @ApiResponses(value = {
  71             @ApiResponse(code = HttpStatus.NOT_FOUND_404, message = "microservice not found",
  72                     response = String.class),
  73             @ApiResponse(code = HttpStatus.UNSUPPORTED_MEDIA_TYPE_415,
  74                     message = "Unprocessable MicroServiceInfo Entity ", response = String.class),
  75             @ApiResponse(code = HttpStatus.INTERNAL_SERVER_ERROR_500,
  76                     message = "server internal error", response = CommonErrorResponse.class)})
  77     @Timed
  78     public Response getServiceTemplateById(
  79             @ApiParam(value = "service template id") @PathParam("servicetemplateid") String servicetemplateid) {
  80         try {
  81             ServiceTemplate st =
  82                     ServiceTemplateWrapper.getInstance().getServiceTemplateById(servicetemplateid);
  83             return Response.status(Response.Status.OK).entity(st).build();
  84         } catch (CatalogResourceException e) {
  85             logger.error("getServiceTemplateById failed.", e);
  86             throw RestUtils.newInternalServerErrorException(e);
  87         }
  88     }
  89
  90
  91     /**
  92      * @param status
  93      * @param deletionPending
  94      * @return
  95      */
  96     @GET
  97     @Consumes(MediaType.APPLICATION_JSON)
  98     @Produces(MediaType.APPLICATION_JSON)
  99     @ApiOperation(value = "Query service template by filter conditions",
 100             response = ServiceTemplate.class, responseContainer = "List")
 101     @ApiResponses(value = {
 102             @ApiResponse(code = HttpStatus.NOT_FOUND_404, message = "microservice not found",
 103                     response = String.class),
 104             @ApiResponse(code = HttpStatus.UNSUPPORTED_MEDIA_TYPE_415,
 105                     message = "Unprocessable MicroServiceInfo Entity ", response = String.class),
 106             @ApiResponse(code = HttpStatus.INTERNAL_SERVER_ERROR_500,
 107                     message = "server internal error", response = CommonErrorResponse.class)})
 108     @Timed
 109     public Response getServiceTemplates(
 110             @ApiParam(value = "template status") @QueryParam("status") String status,
 111             @ApiParam(value = "delay to delete") @QueryParam("deletionPending") boolean deletionPending) {
 112         try {
 113             ServiceTemplate[] sts =
 114                     ServiceTemplateWrapper.getInstance().getServiceTemplates(status,
 115                             deletionPending);
 116             return Response.status(Response.Status.OK).entity(sts).build();
 117         } catch (CatalogResourceException e) {
 118             logger.error("getServiceTemplates failed.", e);
 119             throw RestUtils.newInternalServerErrorException(e);
 120         }
 121
 122     }
 123
 124     /**
 125      * @param nodeTypeIds
 126      * @return
 127      */
 128     @Path("/nesting")
 129     @GET
 130     @Consumes(MediaType.APPLICATION_JSON)
 131     @Produces(MediaType.APPLICATION_JSON)
 132     @ApiOperation(value = "Query nesting service template of a node type",
 133             response = ServiceTemplate.class, responseContainer = "List")
 134     @ApiResponses(value = {
 135             @ApiResponse(code = HttpStatus.NOT_FOUND_404, message = "microservice not found",
 136                     response = String.class),
 137             @ApiResponse(code = HttpStatus.UNSUPPORTED_MEDIA_TYPE_415,
 138                     message = "Unprocessable MicroServiceInfo Entity ", response = String.class),
 139             @ApiResponse(code = HttpStatus.INTERNAL_SERVER_ERROR_500,
 140                     message = "server internal error", response = CommonErrorResponse.class)})
 141     @Timed
 142     public Response getNestingServiceTemplate(
 143             @ApiParam(value = "Node Type Id", required = true) @QueryParam("nodeTypeIds") String nodeTypeIds) {
 144         try {
 145             if (ToolUtil.isTrimedEmptyString(nodeTypeIds)) {
 146                 throw new CatalogBadRequestException("nodeTypeIds is null.");
 147             }
 148             String[] tmpNodeTypeIds = nodeTypeIds.split(",");
 149             ServiceTemplate[] sts =
 150                     ServiceTemplateWrapper.getInstance().getNestingServiceTemplate(
 151                             ToolUtil.TrimedStringArray(tmpNodeTypeIds));
 152             return Response.status(Response.Status.OK).entity(sts).build();
 153         } catch (CatalogResourceException e) {
 154             logger.error("getNestingServiceTemplate failed.", e);
 155             throw RestUtils.newInternalServerErrorException(e);
 156         } catch (CatalogBadRequestException e) {
 157             logger.error("getNestingServiceTemplate failed.", e);
 158             throw RestUtils.newBadRequestException(e);
 159         }
 160     }
 161
 162     /**
 163      * @param nodeTypeId
 164      * @return
 165      */
 166     @Path("/queryingrawdata")
 167     @POST
 168     @Consumes(MediaType.APPLICATION_JSON)
 169     @Produces(MediaType.APPLICATION_JSON)
 170     @ApiOperation(value = "Query raw data of a service template by csar id",
 171             response = ServiceTemplateRawData.class)
 172     @ApiResponses(value = {
 173             @ApiResponse(code = HttpStatus.NOT_FOUND_404, message = "microservice not found",
 174                     response = String.class),
 175             @ApiResponse(code = HttpStatus.UNSUPPORTED_MEDIA_TYPE_415,
 176                     message = "Unprocessable MicroServiceInfo Entity ", response = String.class),
 177             @ApiResponse(code = HttpStatus.INTERNAL_SERVER_ERROR_500,
 178                     message = "server internal error", response = CommonErrorResponse.class)})
 179     @Timed
 180     public Response getServiceTemplateRawData(
 181             @ApiParam(value = "Query Service Template Raw Data Condition", required = true) QueryRawDataCondition queryCondition) {
 182         try {
 183             ServiceTemplateRawData stRowData =
 184                     ServiceTemplateWrapper.getInstance().getServiceTemplateRawData(queryCondition);
 185             return Response.status(Response.Status.OK).entity(stRowData).build();
 186         } catch (CatalogResourceException e) {
 187             logger.error("getServiceTemplateRawData failed.", e);
 188             throw RestUtils.newInternalServerErrorException(e);
 189         } catch (CatalogBadRequestException e) {
 190             logger.error("getServiceTemplateRawData failed.", e);
 191             throw RestUtils.newBadRequestException(e);
 192         }
 193     }
 194
 195
 196     /**
 197      * @param serviceTemplateId
 198      * @return
 199      */
 200     @Path("/{serviceTemplateId}/operations")
 201     @GET
 202     @Consumes(MediaType.APPLICATION_JSON)
 203     @Produces(MediaType.APPLICATION_JSON)
 204     @ApiOperation(value = "Query operation list of service template",
 205             response = ServiceTemplateOperation.class, responseContainer = "List")
 206     @ApiResponses(value = {
 207             @ApiResponse(code = HttpStatus.NOT_FOUND_404, message = "microservice not found",
 208                     response = String.class),
 209             @ApiResponse(code = HttpStatus.UNSUPPORTED_MEDIA_TYPE_415,
 210                     message = "Unprocessable MicroServiceInfo Entity ", response = String.class),
 211             @ApiResponse(code = HttpStatus.INTERNAL_SERVER_ERROR_500,
 212                     message = "server internal error", response = CommonErrorResponse.class)})
 213     @Timed
 214     public Response getServiceTemplateOperations(@ApiParam(value = "Service Template Id",
 215             required = true) @PathParam("serviceTemplateId") String serviceTemplateId) {
 216         try {
 217             ServiceTemplateOperation[] operations =
 218                     ServiceTemplateWrapper.getInstance().getTemplateOperations(serviceTemplateId);
 219             return Response.status(Response.Status.OK).entity(operations).build();
 220         } catch (CatalogResourceException e) {
 221             logger.error("getServiceTemplateOperations failed.", e);
 222             throw RestUtils.newInternalServerErrorException(e);
 223         }
 224
 225     }
 226
 227     /**
 228      * @param serviceTemplateId
 229      * @param operationName
 230      * @return
 231      */
 232     @Path("/{serviceTemplateId}/operations/{operationName}/parameters")
 233     @GET
 234     @Consumes(MediaType.APPLICATION_JSON)
 235     @Produces(MediaType.APPLICATION_JSON)
 236     @ApiOperation(value = "Query input parameters of a specified operation",
 237             response = InputParameter.class, responseContainer = "List")
 238     @ApiResponses(value = {
 239             @ApiResponse(code = HttpStatus.NOT_FOUND_404, message = "microservice not found",
 240                     response = String.class),
 241             @ApiResponse(code = HttpStatus.UNSUPPORTED_MEDIA_TYPE_415,
 242                     message = "Unprocessable MicroServiceInfo Entity ", response = String.class),
 243             @ApiResponse(code = HttpStatus.INTERNAL_SERVER_ERROR_500,
 244                     message = "server internal error", response = CommonErrorResponse.class)})
 245     @Timed
 246     public Response getParametersByOperationName(
 247             @ApiParam(value = "Service Template Id", required = true) @PathParam("serviceTemplateId") String serviceTemplateId,
 248             @ApiParam(value = "Operation Name", required = true) @PathParam("operationName") String operationName) {
 249         try {
 250             InputParameter[] inputs =
 251                     ServiceTemplateWrapper.getInstance().getParametersByOperationName(
 252                             serviceTemplateId, operationName);
 253             return Response.status(Response.Status.OK).entity(inputs).build();
 254         } catch (CatalogResourceException e) {
 255             logger.error("getParametersByOperationId failed.", e);
 256             throw RestUtils.newInternalServerErrorException(e);
 257         }
 258
 259     }
 260
 261     /**
 262      * @param servicetemplateid
 263      * @return
 264      */
 265     @Path("/{servicetemplateid}/parameters")
 266     @GET
 267     @Consumes(MediaType.APPLICATION_JSON)
 268     @Produces(MediaType.APPLICATION_JSON)
 269     @ApiOperation(value = "Query input parameters of service template",
 270             response = InputParameter.class, responseContainer = "List")
 271     @ApiResponses(value = {
 272             @ApiResponse(code = HttpStatus.NOT_FOUND_404, message = "microservice not found",
 273                     response = String.class),
 274             @ApiResponse(code = HttpStatus.UNSUPPORTED_MEDIA_TYPE_415,
 275                     message = "Unprocessable MicroServiceInfo Entity ", response = String.class),
 276             @ApiResponse(code = HttpStatus.INTERNAL_SERVER_ERROR_500,
 277                     message = "server internal error", response = CommonErrorResponse.class)})
 278     @Timed
 279     public Response getServiceTemplateParameters(@ApiParam(value = "service template id",
 280             required = true) @PathParam("servicetemplateid") String servicetemplateid) {
 281         try {
 282             InputParameter[] inputs =
 283                     ServiceTemplateWrapper.getInstance().getServiceTemplateParameters(
 284                             servicetemplateid);
 285             return Response.status(Response.Status.OK).entity(inputs).build();
 286         } catch (CatalogResourceException e) {
 287             logger.error("getServiceTemplateParameters failed.", e);
 288             throw RestUtils.newInternalServerErrorException(e);
 289         }
 290
 291     }
 292
 293     /**
 294      * @param serviceTemplateId
 295      * @param types
 296      * @return
 297      */
 298     @Path("/{serviceTemplateId}/nodetemplates")
 299     @GET
 300     @Consumes(MediaType.APPLICATION_JSON)
 301     @Produces(MediaType.APPLICATION_JSON)
 302     @ApiOperation(value = "Query node template list of a specified service template",
 303             response = NodeTemplate.class, responseContainer = "List")
 304     @ApiResponses(value = {
 305             @ApiResponse(code = HttpStatus.NOT_FOUND_404, message = "microservice not found",
 306                     response = String.class),
 307             @ApiResponse(code = HttpStatus.UNSUPPORTED_MEDIA_TYPE_415,
 308                     message = "Unprocessable MicroServiceInfo Entity ", response = String.class),
 309             @ApiResponse(code = HttpStatus.INTERNAL_SERVER_ERROR_500,
 310                     message = "server internal error", response = CommonErrorResponse.class)})
 311     @Timed
 312     public Response getNodeTemplatesByType(
 313             @ApiParam(value = "Service Template Id", required = true) @PathParam("serviceTemplateId") String serviceTemplateId,
 314             @ApiParam(value = "The type of node template") @QueryParam("types") String types) {
 315         try {
 316             String[] tmpTypes = getSplitedTypes(types);
 317             NodeTemplate[] nts =
 318                     ServiceTemplateWrapper.getInstance().getNodeTemplates(serviceTemplateId,
 319                             ToolUtil.TrimedStringArray(tmpTypes));
 320             return Response.status(Response.Status.OK).entity(nts).build();
 321         } catch (CatalogResourceException e) {
 322             logger.error("getNodeTemplateList failed.", e);
 323             throw RestUtils.newInternalServerErrorException(e);
 324         }
 325
 326     }
 327
 328
 329     private String[] getSplitedTypes(String types) {
 330         if (ToolUtil.isTrimedEmptyString(types)) {
 331             return new String[0];
 332         }
 333
 334         return types.split(",");
 335     }
 336
 337     /**
 338      * @param serviceTemplateId
 339      * @param nodeTemplateId
 340      * @return
 341      */
 342     @Path("/{serviceTemplateId}/nodetemplates/{nodeTemplateId}")
 343     @GET
 344     @Consumes(MediaType.APPLICATION_JSON)
 345     @Produces(MediaType.APPLICATION_JSON)
 346     @ApiOperation(value = "Query node template by node template id", response = NodeTemplate.class)
 347     @ApiResponses(value = {
 348             @ApiResponse(code = HttpStatus.NOT_FOUND_404, message = "microservice not found",
 349                     response = String.class),
 350             @ApiResponse(code = HttpStatus.UNSUPPORTED_MEDIA_TYPE_415,
 351                     message = "Unprocessable MicroServiceInfo Entity ", response = String.class),
 352             @ApiResponse(code = HttpStatus.INTERNAL_SERVER_ERROR_500,
 353                     message = "server internal error", response = CommonErrorResponse.class)})
 354     @Timed
 355     public Response getNodeTemplateById(
 356             @ApiParam(value = "Service Template Id", required = true) @PathParam("serviceTemplateId") String serviceTemplateId,
 357             @ApiParam(value = "Node Template Id", required = true) @PathParam("nodeTemplateId") String nodeTemplateId) {
 358         try {
 359             NodeTemplate nt =
 360                     ServiceTemplateWrapper.getInstance().getNodeTemplateById(serviceTemplateId,
 361                             nodeTemplateId);
 362             return Response.status(Response.Status.OK).entity(nt).build();
 363         } catch (CatalogResourceException e) {
 364             logger.error("getNodeTemplateById failed.", e);
 365             throw RestUtils.newInternalServerErrorException(e);
 366         }
 367
 368     }
 369
 370     // /**
 371     // * @param servicetemplateid
 372     // * @return
 373     // */
 374     // @Path("/{servicetemplateid}/nfvtemplate")
 375     // @POST
 376     // @Consumes(MediaType.APPLICATION_JSON)
 377     // @Produces(MediaType.APPLICATION_JSON)
 378     // @ApiOperation(value =
 379     // "Query node template detail of a specified service template", response =
 380     // NfvTemplate.class)
 381     // @ApiResponses(value = {
 382     // @ApiResponse(code = HttpStatus.NOT_FOUND_404, message =
 383     // "microservice not found", response = String.class),
 384     // @ApiResponse(code = HttpStatus.UNSUPPORTED_MEDIA_TYPE_415, message =
 385     // "Unprocessable MicroServiceInfo Entity ", response = String.class),
 386     // @ApiResponse(code = HttpStatus.INTERNAL_SERVER_ERROR_500, message =
 387     // "server internal error", response = CommonErrorResponse.class) })
 388     // @Timed
 389     // public Response getNfvTemplate(
 390     // @ApiParam(value = "service template id", required = true)
 391     // @PathParam("servicetemplateid") String servicetemplateid) {
 392     // try {
 393     // NfvTemplate nfvTemplate = ServiceTemplateWrapper.getInstance()
 394     // .getNfvTemplate(servicetemplateid);
 395     // return Response.status(Response.Status.OK).entity(nfvTemplate)
 396     // .build();
 397     // } catch (CatalogResourceException e) {
 398     // logger.error("getNfvTemplate failed.", e);
 399     // throw RestUtils.newInternalServerErrorException(e);
 400     // }
 401     //
 402     // }
 403
 404     /**
 405      *
 406      * @return
 407      */
 408     @Path("/test")
 409     @GET
 410     @Consumes(MediaType.APPLICATION_JSON)
 411     @Produces(MediaType.APPLICATION_JSON)
 412     @ApiOperation(value = "test", response = String.class, responseContainer = "List")
 413     @ApiResponses(value = {
 414             @ApiResponse(code = HttpStatus.NOT_FOUND_404, message = "microservice not found",
 415                     response = String.class),
 416             @ApiResponse(code = HttpStatus.UNSUPPORTED_MEDIA_TYPE_415,
 417                     message = "Unprocessable MicroServiceInfo Entity ", response = String.class),
 418             @ApiResponse(code = HttpStatus.INTERNAL_SERVER_ERROR_500,
 419                     message = "server internal error", response = CommonErrorResponse.class)})
 420     @Timed
 421     public Response test() {
 422         try {
 423             ToscaYamlModelParser parser = new ToscaYamlModelParser();
 424             parser.parse("pk11111", "C:\\Users\\10090474\\Desktop\\3\\NS_core\\NS_core.zip");
 425             String[] strs = {"111", "222", null, null, "555"};
 426             Response.status(Response.Status.OK).entity(strs).build();
 427             throw new CatalogResourceException("test failed.");
 428         } catch (CatalogResourceException e) {
 429             logger.error("test failed.", e);
 430             throw RestUtils.newInternalServerErrorException(e);
 431         }
 432     }
 433
 434
 435 }