huawei/vnfmadapter/VnfmadapterService/service/src/main/java/org/openo/nfvo/vnfmadapter/service/rest/VnfRoa.java

   1 /*
   2  * Copyright 2016-2017 Huawei Technologies Co., Ltd.
   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.nfvo.vnfmadapter.service.rest;
  18
  19 import java.util.HashMap;
  20 import java.util.Map;
  21
  22 import javax.servlet.http.HttpServletRequest;
  23 import javax.servlet.http.HttpServletResponse;
  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.Context;
  32 import javax.ws.rs.core.MediaType;
  33
  34 import org.apache.commons.collections.map.UnmodifiableMap;
  35 import org.apache.commons.lang3.StringUtils;
  36 import org.openo.baseservice.remoteservice.exception.ServiceException;
  37 import org.openo.nfvo.vnfmadapter.common.VnfmJsonUtil;
  38 import org.openo.nfvo.vnfmadapter.service.constant.Constant;
  39 import org.openo.nfvo.vnfmadapter.service.process.VnfMgr;
  40 import org.slf4j.Logger;
  41 import org.slf4j.LoggerFactory;
  42
  43 import net.sf.json.JSONObject;
  44
  45 /**
  46  * Provide interfaces for instantiate or terminate VNF.
  47  * <br/>
  48  *
  49  * @author
  50  * @version NFVO 0.5 Aug 24, 2016
  51  */
  52 @SuppressWarnings("unchecked")
  53 @Path("/openoapi/hwvnfm/v1")
  54 @Consumes(MediaType.APPLICATION_JSON)
  55 @Produces(MediaType.APPLICATION_JSON)
  56 public class VnfRoa {
  57
  58     private static final Logger LOG = LoggerFactory.getLogger(VnfRoa.class);
  59
  60     private VnfMgr vnfMgr;
  61
  62     private static Map<String, String> PROGRESSITEM;
  63
  64     private static Map<String, String> JOBSTATUSITEM;
  65
  66     static {
  67         Map<String, String> map = new HashMap<>();
  68         map.put("Building", "50");
  69         map.put("Active", "100");
  70         map.put("Stopped", "50");
  71         map.put("Error", "100");
  72         PROGRESSITEM = UnmodifiableMap.decorate(map);
  73
  74         map = new HashMap<>();
  75         map.put("Building", "processing");
  76         map.put("Active", "finished");
  77         map.put("Stopped", "processing");
  78         map.put("Error", "error");
  79         JOBSTATUSITEM = UnmodifiableMap.decorate(map);
  80     }
  81
  82     public void setVnfMgr(VnfMgr vnfMgr) {
  83         this.vnfMgr = vnfMgr;
  84     }
  85
  86     /**
  87      * Scale VNF
  88      *
  89      * @param context
  90      *            * {
  91      *            "vnfInstanceId":"5",
  92      *            "type":"SCALE_OUT",
  93      *            "aspectId":"101",
  94      *            "numberOfSteps":"1",
  95      *            "additionalParam":{}
  96      *            }
  97      * @param resp
  98      * @param vnfmId
  99      * @return
 100      *         {
 101      *         "jobId":"1"
 102      *         }
 103      * @throws ServiceException
 104      */
 105     @POST
 106     @Path("/{vnfmId}/vnfs/{vnfInstanceId}/scale")
 107     public String scaleVnf(@Context HttpServletRequest context, @Context HttpServletResponse resp,
 108             @PathParam("vnfmId") String vnfmId, @PathParam("vnfInstanceId") String vnfInstanceId)
 109             throws ServiceException {
 110         JSONObject jsonObject = VnfmJsonUtil.getJsonFromContexts(context);
 111         LOG.info("function=scaleVNF, msg=enter to scale a vnf. request body:" + jsonObject);
 112         JSONObject result = new JSONObject();
 113         String msg = "";
 114         if(null == jsonObject) {
 115             msg = "the parameters do not meet the requirements,please check it!";
 116             LOG.error("function=scalVnf," + msg);
 117             resp.setStatus(Constant.HTTP_NOT_ACCEPTABLE);
 118             result.put("msg", msg);
 119             return result.toString();
 120         }
 121
 122         result = vnfMgr.scaleVNF(jsonObject, vnfmId, vnfInstanceId);
 123         LOG.info("function=scaleVNF,result=" + result.toString());
 124         if(result.getInt(Constant.RETCODE) == Constant.REST_FAIL) {
 125             LOG.error("function=scaleVNF, msg=scaleVnf fail");
 126             resp.setStatus(Constant.HTTP_INNERERROR);
 127             return result.toString();
 128         }
 129         return JSONObject.fromObject(result.getJSONObject("data")).toString();
 130     }
 131
 132     /**
 133      * Provide function for instantiate VNF
 134      * <br/>
 135      *
 136      * @param context
 137      * @param resp
 138      * @param vnfmId
 139      * @return
 140      * @throws ServiceException
 141      * @since NFVO 0.5
 142      */
 143     @POST
 144     @Path("/{vnfmId}/vnfs")
 145     public String addVnf(@Context HttpServletRequest context, @Context HttpServletResponse resp,
 146             @PathParam("vnfmId") String vnfmId) throws ServiceException {
 147         LOG.warn("function=addVnf, msg=enter to add a vnf");
 148         JSONObject subJsonObject = VnfmJsonUtil.getJsonFromContexts(context);
 149         JSONObject restJson = new JSONObject();
 150
 151         if(null == subJsonObject) {
 152             LOG.error("function=addVnf, msg=params are insufficient");
 153             resp.setStatus(Constant.HTTP_INNERERROR);
 154             return restJson.toString();
 155         }
 156         LOG.info("addVnf request info from (LCM):" + subJsonObject);
 157         restJson = vnfMgr.addVnf(subJsonObject, vnfmId);
 158
 159         if(restJson.getInt(Constant.RETCODE) == Constant.REST_FAIL) {
 160             LOG.error("function=addVnf, msg=addvnf fail");
 161             resp.setStatus(Constant.HTTP_INNERERROR);
 162             return restJson.toString();
 163         }
 164
 165         return JSONObject.fromObject(restJson.getJSONObject("data")).toString();
 166     }
 167
 168     /**
 169      * Provide function for terminate VNF
 170      * <br/>
 171      *
 172      * @param vnfmId
 173      * @param resp
 174      * @param vnfInstanceId
 175      * @param context
 176      * @return
 177      * @throws ServiceException
 178      * @since NFVO 0.5
 179      */
 180     @POST
 181     @Path("/{vnfmId}/vnfs/{vnfInstanceId}/terminate")
 182     public String delVnf(@PathParam("vnfmId") String vnfmId, @Context HttpServletResponse resp,
 183             @PathParam("vnfInstanceId") String vnfInstanceId, @Context HttpServletRequest context)
 184             throws ServiceException {
 185         LOG.warn("function=delVnf, msg=enter to delete a vnf: vnfInstanceId: {}, vnfmId: {}", vnfInstanceId, vnfmId);
 186         JSONObject vnfObject = VnfmJsonUtil.getJsonFromContexts(context);
 187         JSONObject restJson = new JSONObject();
 188
 189         if(StringUtils.isEmpty(vnfInstanceId) || StringUtils.isEmpty(vnfmId)) {
 190             resp.setStatus(Constant.HTTP_INNERERROR);
 191             return restJson.toString();
 192         }
 193
 194         restJson = vnfMgr.deleteVnf(vnfInstanceId, vnfmId, vnfObject);
 195         if(restJson.getInt(Constant.RETCODE) == Constant.REST_FAIL) {
 196             LOG.error("function=delVnf, msg=delVnf fail");
 197             resp.setStatus(Constant.HTTP_INNERERROR);
 198             return restJson.toString();
 199         }
 200
 201         return JSONObject.fromObject(restJson.getJSONObject("data")).toString();
 202     }
 203
 204     /**
 205      * Provide function for get VNF
 206      * <br/>
 207      *
 208      * @param vnfmId
 209      * @param resp
 210      * @param vnfInstanceId
 211      * @param context
 212      * @return
 213      * @throws ServiceException
 214      * @since NFVO 0.5
 215      */
 216     @GET
 217     @Path("/{vnfmId}/vnfs/{vnfInstanceId}")
 218     public String getVnf(@PathParam("vnfmId") String vnfmId, @Context HttpServletResponse resp,
 219             @PathParam("vnfInstanceId") String vnfInstanceId, @Context HttpServletRequest context)
 220             throws ServiceException {
 221         LOG.warn("function=getVnf, msg=enter to get a vnf: vnfInstanceId: {}, vnfmId: {}", vnfInstanceId, vnfmId);
 222         JSONObject restJson = new JSONObject();
 223
 224         if(StringUtils.isEmpty(vnfInstanceId) || StringUtils.isEmpty(vnfmId)) {
 225             resp.setStatus(Constant.HTTP_INNERERROR);
 226             return restJson.toString();
 227         }
 228
 229         restJson = vnfMgr.getVnf(vnfInstanceId, vnfmId);
 230         if(restJson.getInt(Constant.RETCODE) == Constant.REST_FAIL) {
 231             LOG.error("function=getVnf, msg=getVnf fail");
 232             resp.setStatus(Constant.HTTP_INNERERROR);
 233             return restJson.toString();
 234         }
 235
 236         restJson.remove(Constant.RETCODE);
 237         return restJson.toString();
 238     }
 239
 240     /**
 241      * Provide function for get job
 242      * <br/>
 243      *
 244      * @param jobId
 245      * @param vnfmId
 246      * @param resp
 247      * @param responseId
 248      * @return
 249      * @throws ServiceException
 250      * @since NFVO 0.5
 251      */
 252     @GET
 253     @Path("/{vnfmId}/jobs/{jobId}")
 254     public String getJob(@PathParam("jobId") String jobId, @PathParam("vnfmId") String vnfmId,
 255             @Context HttpServletResponse resp, @QueryParam("@responseId") String responseId) throws ServiceException {
 256         LOG.warn("function=getJob, msg=enter to get a job: jobId: {}", jobId);
 257         JSONObject restJson = new JSONObject();
 258
 259         if(StringUtils.isEmpty(jobId) || StringUtils.isEmpty(vnfmId)) {
 260             resp.setStatus(Constant.HTTP_INNERERROR);
 261             return restJson.toString();
 262         }
 263
 264         restJson = vnfMgr.getJob(jobId, vnfmId);
 265         if(restJson.getInt(Constant.RETCODE) == Constant.REST_FAIL) {
 266             LOG.error("function=getJob, msg=getJob fail");
 267             resp.setStatus(Constant.HTTP_INNERERROR);
 268             return restJson.toString();
 269         }
 270
 271         return getJobBody(restJson);
 272     }
 273
 274     private String getJobBody(JSONObject restJson) {
 275         JSONObject responseJson = new JSONObject();
 276         JSONObject jobInfoJson = new JSONObject();
 277         JSONObject retJson = restJson.getJSONArray("data").getJSONObject(0);
 278         jobInfoJson.put("jobId", retJson.getString("id"));
 279         responseJson.put("progress", PROGRESSITEM.get(retJson.getString(Constant.STATUS)));
 280         responseJson.put("status", JOBSTATUSITEM.get(retJson.getString(Constant.STATUS)));
 281         responseJson.put("errorCode", "null");
 282         responseJson.put("responseId", PROGRESSITEM.get(retJson.getString(Constant.STATUS)));
 283         jobInfoJson.put("responsedescriptor", responseJson);
 284         return jobInfoJson.toString();
 285     }
 286 }