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