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