msb-core/apiroute/apiroute-service/src/main/java/org/openo/msb/resources/MicroServiceResource.java

   1 /**
   2  * Copyright 2016 2015-2016 ZTE, Inc. and others. All rights reserved.
   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.msb.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 java.net.URI;
  25
  26 import javax.servlet.http.HttpServletRequest;
  27 import javax.ws.rs.DELETE;
  28 import javax.ws.rs.DefaultValue;
  29 import javax.ws.rs.GET;
  30 import javax.ws.rs.POST;
  31 import javax.ws.rs.PUT;
  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.Context;
  37 import javax.ws.rs.core.MediaType;
  38 import javax.ws.rs.core.Response;
  39 import javax.ws.rs.core.UriInfo;
  40
  41 import org.apache.commons.lang3.StringUtils;
  42 import org.apache.http.HttpStatus;
  43 import org.openo.msb.api.MicroServiceFullInfo;
  44 import org.openo.msb.api.MicroServiceInfo;
  45 import org.openo.msb.wrapper.MicroServiceWrapper;
  46 import org.openo.msb.wrapper.util.MicroServiceUtil;
  47 import org.slf4j.Logger;
  48 import org.slf4j.LoggerFactory;
  49
  50 import com.codahale.metrics.annotation.Timed;
  51
  52 @Path("/services")
  53 @Api(tags = {"MSB-Service Resource"})
  54 @Produces(MediaType.APPLICATION_JSON)
  55 public class MicroServiceResource {
  56
  57     @Context
  58     UriInfo uriInfo; // actual uri info
  59
  60
  61     private static final Logger LOGGER = LoggerFactory.getLogger(MicroServiceResource.class);
  62
  63     @GET
  64     @Path("/")
  65     @ApiOperation(value = "get all microservices ", code = HttpStatus.SC_OK, response = MicroServiceFullInfo.class, responseContainer = "List")
  66     @ApiResponses(value = {@ApiResponse(code = HttpStatus.SC_INTERNAL_SERVER_ERROR, message = "get microservice List  fail", response = String.class)})
  67     @Produces(MediaType.APPLICATION_JSON)
  68     @Timed
  69     public MicroServiceFullInfo[] getMicroService() {
  70         return MicroServiceWrapper.getInstance().getAllMicroServiceInstances();
  71     }
  72
  73     @POST
  74     @Path("/")
  75     @ApiOperation(value = "add one microservice ", code = HttpStatus.SC_CREATED, response = MicroServiceFullInfo.class)
  76     @ApiResponses(value = {
  77             @ApiResponse(code = HttpStatus.SC_UNSUPPORTED_MEDIA_TYPE, message = "Unprocessable MicroServiceInfo Entity ", response = String.class),
  78             @ApiResponse(code = HttpStatus.SC_INTERNAL_SERVER_ERROR, message = "add microservice fail", response = String.class),
  79             @ApiResponse(code = HttpStatus.SC_BAD_REQUEST, message = "Unprocessable MicroServiceInfo JSON REQUEST", response = String.class)})
  80     @Produces(MediaType.APPLICATION_JSON)
  81     @Timed
  82     public Response addMicroService(
  83             @ApiParam(value = "MicroServiceInfo Instance Info", required = true) MicroServiceInfo microServiceInfo,
  84             @Context HttpServletRequest request,
  85             @ApiParam(value = "createOrUpdate", required = false) @QueryParam("createOrUpdate") @DefaultValue("true") boolean createOrUpdate,
  86             @ApiParam(value = "port", required = false) @QueryParam("port") @DefaultValue("") String port) {
  87
  88        String ip=MicroServiceUtil.getRealIp(request);
  89
  90         MicroServiceFullInfo microServiceFullInfo =
  91                 MicroServiceWrapper.getInstance().saveMicroServiceInstance(microServiceInfo,
  92                     createOrUpdate,ip,port);
  93         URI returnURI =
  94                 uriInfo.getAbsolutePathBuilder()
  95                         .path("/" + microServiceInfo.getServiceName() + "/version/"
  96                                 + microServiceInfo.getVersion()).build();
  97         return Response.created(returnURI).entity(microServiceFullInfo).build();
  98     }
  99
 100
 101
 102     @GET
 103     @Path("/{serviceName}/version/{version}")
 104     @ApiOperation(value = "get one microservice ", code = HttpStatus.SC_OK, response = MicroServiceFullInfo.class)
 105     @ApiResponses(value = {
 106             @ApiResponse(code = HttpStatus.SC_NOT_FOUND, message = "microservice not found", response = String.class),
 107             @ApiResponse(code = HttpStatus.SC_UNSUPPORTED_MEDIA_TYPE, message = "Unprocessable MicroServiceInfo Entity ", response = String.class),
 108             @ApiResponse(code = HttpStatus.SC_INTERNAL_SERVER_ERROR, message = "get microservice fail", response = String.class)})
 109     @Produces(MediaType.APPLICATION_JSON)
 110     @Timed
 111     public MicroServiceFullInfo getMicroService(
 112             @ApiParam(value = "microservice serviceName") @PathParam("serviceName") String serviceName,
 113             @ApiParam(value = "microservice version,if the version is empty, please enter \"null\"") @PathParam("version") @DefaultValue("") String version,
 114             @ApiParam(value = "port", required = false) @QueryParam("port") @DefaultValue("") String port) {
 115
 116
 117         return MicroServiceWrapper.getInstance().getMicroServiceInstance(serviceName, version,port);
 118
 119
 120     }
 121
 122     @PUT
 123     @Path("/{serviceName}/version/{version}")
 124     @ApiOperation(value = "update one microservice by serviceName and version", code = HttpStatus.SC_CREATED, response = MicroServiceFullInfo.class)
 125     @ApiResponses(value = {
 126             @ApiResponse(code = HttpStatus.SC_UNSUPPORTED_MEDIA_TYPE, message = "Unprocessable MicroServiceInfo Entity ", response = String.class),
 127             @ApiResponse(code = HttpStatus.SC_INTERNAL_SERVER_ERROR, message = "update microservice fail", response = String.class),
 128             @ApiResponse(code = HttpStatus.SC_BAD_REQUEST, message = "Unprocessable MicroServiceInfo JSON REQUEST", response = String.class)})
 129     @Produces(MediaType.APPLICATION_JSON)
 130     @Timed
 131     public Response updateMicroService(
 132             @ApiParam(value = "microservice serviceName") @PathParam("serviceName") String serviceName,
 133             @ApiParam(value = "microservice version,if the version is empty, please enter \"null\"") @PathParam("version") @DefaultValue("") String version,
 134             @ApiParam(value = "microservice Instance Info", required = true) MicroServiceInfo microServiceInfo) {
 135
 136         MicroServiceFullInfo microServiceFullInfo = MicroServiceWrapper.getInstance().updateMicroServiceInstance(serviceName, version,
 137                 microServiceInfo);
 138         return Response.created(uriInfo.getAbsolutePathBuilder().build()).entity(microServiceFullInfo).build();
 139
 140     }
 141
 142     @PUT
 143     @Path("/{serviceName}/version/{version}/nodes/{ip}/{port}")
 144     @ApiOperation(value = "update  single node by serviceName and version and node", code = HttpStatus.SC_CREATED, response = MicroServiceFullInfo.class)
 145     @ApiResponses(value = {
 146             @ApiResponse(code = HttpStatus.SC_UNSUPPORTED_MEDIA_TYPE, message = "Unprocessable MicroServiceInfo Entity ", response = String.class),
 147             @ApiResponse(code = HttpStatus.SC_NOT_FOUND, message = "microservice not found", response = String.class),
 148             @ApiResponse(code = HttpStatus.SC_INTERNAL_SERVER_ERROR, message = "update node fail", response = String.class)})
 149     @Produces(MediaType.APPLICATION_JSON)
 150     @Timed
 151     public Response updateNode(
 152             @ApiParam(value = "microservice serviceName", required = true) @PathParam("serviceName") String serviceName,
 153             @ApiParam(value = "microservice version,if the version is empty, please enter \"null\"", required = false) @PathParam("version") @DefaultValue("") String version,
 154             @ApiParam(value = "ip") @PathParam("ip") String ip,
 155             @ApiParam(value = "port") @PathParam("port") String port,
 156             @ApiParam(value = "ttl") @QueryParam("ttl") int ttl) {
 157
 158         MicroServiceFullInfo microServiceFullInfo = MicroServiceWrapper.getInstance().updateMicroServiceNode(serviceName, version, ip,port, ttl);
 159
 160         return Response.created(uriInfo.getAbsolutePathBuilder().build()).entity(microServiceFullInfo).build();
 161
 162     }
 163
 164
 165
 166     @DELETE
 167     @Path("/{serviceName}/version/{version}/nodes/{ip}/{port}")
 168     @ApiOperation(value = "delete single node by serviceName and version and node", code = HttpStatus.SC_NO_CONTENT)
 169     @ApiResponses(value = {
 170             @ApiResponse(code = HttpStatus.SC_NO_CONTENT, message = "delete node succeed "),
 171             @ApiResponse(code = HttpStatus.SC_NOT_FOUND, message = "node not found", response = String.class),
 172             @ApiResponse(code = HttpStatus.SC_UNSUPPORTED_MEDIA_TYPE, message = "Unprocessable MicroServiceInfo Entity ", response = String.class),
 173             @ApiResponse(code = HttpStatus.SC_INTERNAL_SERVER_ERROR, message = "delete node fail", response = String.class)})
 174     @Produces(MediaType.APPLICATION_JSON)
 175     @Timed
 176     public void deleteNode(
 177             @ApiParam(value = "microservice serviceName", required = true) @PathParam("serviceName") String serviceName,
 178             @ApiParam(value = "microservice version,if the version is empty, please enter \"null\"", required = false) @PathParam("version") @DefaultValue("") String version,
 179             @ApiParam(value = "ip") @PathParam("ip") String ip,
 180             @ApiParam(value = "port") @PathParam("port") String port) {
 181
 182         MicroServiceWrapper.getInstance().deleteMicroServiceInstance(serviceName, version, ip,port);
 183
 184     }
 185
 186
 187     @DELETE
 188     @Path("/{serviceName}/version/{version}")
 189     @ApiOperation(value = "delete one full microservice by serviceName and version", code = HttpStatus.SC_NO_CONTENT)
 190     @ApiResponses(value = {
 191             @ApiResponse(code = HttpStatus.SC_NO_CONTENT, message = "delete microservice succeed "),
 192             @ApiResponse(code = HttpStatus.SC_NOT_FOUND, message = "microservice not found", response = String.class),
 193             @ApiResponse(code = HttpStatus.SC_UNSUPPORTED_MEDIA_TYPE, message = "Unprocessable MicroServiceInfo Entity ", response = String.class),
 194             @ApiResponse(code = HttpStatus.SC_INTERNAL_SERVER_ERROR, message = "delete microservice fail", response = String.class)})
 195     @Produces(MediaType.APPLICATION_JSON)
 196     @Timed
 197     public void deleteMicroService(
 198             @ApiParam(value = "microservice serviceName", required = true) @PathParam("serviceName") String serviceName,
 199             @ApiParam(value = "microservice version,if the version is empty, please enter \"null\"", required = false) @PathParam("version") @DefaultValue("") String version,
 200             @ApiParam(value = "port", required = false) @QueryParam("port") @DefaultValue("") String port) {
 201
 202
 203          MicroServiceWrapper.getInstance().deleteMicroService(serviceName, version,port);
 204
 205     }
 206
 207     @PUT
 208     @Path("/{serviceName}/version/{version}/status/{status}")
 209     @ApiOperation(value = "update  microservice status by serviceName and version", code = HttpStatus.SC_CREATED, response = MicroServiceFullInfo.class)
 210     @ApiResponses(value = {
 211             @ApiResponse(code = HttpStatus.SC_UNSUPPORTED_MEDIA_TYPE, message = "Unprocessable MicroServiceInfo Entity ", response = String.class),
 212             @ApiResponse(code = HttpStatus.SC_NOT_FOUND, message = "microservice not found", response = String.class),
 213             @ApiResponse(code = HttpStatus.SC_INTERNAL_SERVER_ERROR, message = "update status fail", response = String.class)})
 214     @Produces(MediaType.APPLICATION_JSON)
 215     @Timed
 216     public Response updateServiceStatus(
 217             @ApiParam(value = "microservice serviceName", required = true) @PathParam("serviceName") String serviceName,
 218             @ApiParam(value = "microservice version,if the version is empty, please enter \"null\"", required = false) @PathParam("version") @DefaultValue("") String version,
 219             @ApiParam(value = "status,1：abled  0：disabled") @PathParam("status") String status) {
 220
 221         MicroServiceFullInfo microServiceFullInfo = MicroServiceWrapper.getInstance().updateMicroServiceStatus(serviceName, version,status);
 222
 223         return Response.created(uriInfo.getAbsolutePathBuilder().build()).entity(microServiceFullInfo).build();
 224
 225     }
 226
 227 //    @PUT
 228 //    @Path("/ttl")
 229 //    @ApiOperation(value = "test json date iso8601 ", code = 200, response = String.class)
 230 //    @Produces(MediaType.APPLICATION_JSON)
 231 //    @Timed
 232 //    public String testIso8601(
 233 //              @ApiParam(value = "microservice Instance Info", required = true) MicroServiceFullInfo microServiceInfo) {
 234 //        Set<NodeInfo> nodes=microServiceInfo.getNodes();
 235 //        String rtn="rtn:";
 236 //        for(NodeInfo node:nodes){
 237 //            Date date=node.getExpiration();
 238 //            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssXXX");
 239 //            String datettl=sdf.format(date);
 240 //            rtn+=datettl;
 241 //        }
 242 //
 243 //
 244 //        return rtn;
 245 //    }
 246 }