huawei/vnfmadapter/VnfmadapterService/service/src/main/java/org/onap/vfc/nfvo/vnfm/svnfm/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.onap.vfc.nfvo.vnfm.svnfm.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.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.common.VnfmJsonUtil;
  37 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.common.VnfmUtil;
  38 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.service.constant.Constant;
  39 import org.onap.vfc.nfvo.vnfm.svnfm.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 VFC 1.0 Aug 24, 2016
  51  */
  52 @SuppressWarnings("unchecked")
  53 @Path("/api/huaweivnfmdriver/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 vnfmId
  90      * @param vnfInstanceId
  91      * @param resp
  92      * @param context
  93      *            {
  94      *            "vnfInstanceId":"5",
  95      *            "type":"SCALE_OUT",
  96      *            "aspectId":"101",
  97      *            "numberOfSteps":"1",
  98      *            "additionalParam":{}
  99      *            }
 100      * @return
 101      *         {
 102      *         "jobId":"1"
 103      *         }
 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         JSONObject jsonObject = VnfmJsonUtil.getJsonFromContexts(context);
 110         LOG.info("function=scaleVNF, msg=enter to scale a vnf. request body:" + jsonObject);
 111         JSONObject result = new JSONObject();
 112         if(null == jsonObject) {
 113             String msg = "the parameters do not meet the requirements,please check it!";
 114             LOG.error("function=scalVnf," + msg);
 115             resp.setStatus(Constant.HTTP_NOT_ACCEPTABLE);
 116             result.put("msg", msg);
 117             return result.toString();
 118         }
 119
 120         result = vnfMgr.scaleVNF(jsonObject, vnfmId, vnfInstanceId);
 121         LOG.info("function=scaleVNF,result=" + result.toString());
 122         if(result.getInt(Constant.RETCODE) == Constant.REST_FAIL) {
 123             LOG.error("function=scaleVNF, msg=scaleVnf fail");
 124             resp.setStatus(Constant.HTTP_INNERERROR);
 125             return result.toString();
 126         }
 127         return JSONObject.fromObject(result.getJSONObject("data")).toString();
 128     }
 129
 130     /**
 131      * Provide function for instantiate VNF
 132      * <br/>
 133      *
 134      * @param context
 135      * @param resp
 136      * @param vnfmId
 137      * @return
 138      * @since VFC 1.0
 139      */
 140     @POST
 141     @Path("/{vnfmId}/vnfs")
 142     public String addVnf(@Context HttpServletRequest context, @Context HttpServletResponse resp,
 143             @PathParam("vnfmId") String vnfmId) {
 144         LOG.warn("function=addVnf, msg=enter to add a vnf");
 145         JSONObject subJsonObject = VnfmJsonUtil.getJsonFromContexts(context);
 146         JSONObject restJson = new JSONObject();
 147
 148         if(null == subJsonObject) {
 149             LOG.error("function=addVnf, msg=params are insufficient");
 150             resp.setStatus(Constant.HTTP_INNERERROR);
 151             return restJson.toString();
 152         }
 153         LOG.info("addVnf request info from (LCM):" + subJsonObject);
 154         restJson = vnfMgr.addVnf(subJsonObject, vnfmId);
 155
 156         if(restJson.getInt(Constant.RETCODE) == Constant.REST_FAIL) {
 157             LOG.error("function=addVnf, msg=addvnf fail");
 158             resp.setStatus(Constant.HTTP_INNERERROR);
 159             return restJson.toString();
 160         }
 161
 162         return JSONObject.fromObject(restJson.getJSONObject("data")).toString();
 163     }
 164
 165     /**
 166      * Provide function for terminate VNF
 167      * <br/>
 168      *
 169      * @param vnfmId
 170      * @param resp
 171      * @param vnfInstanceId
 172      * @param context
 173      * @return
 174      * @since VFC 1.0
 175      */
 176     @POST
 177     @Path("/{vnfmId}/vnfs/{vnfInstanceId}/terminate")
 178     public String delVnf(@PathParam("vnfmId") String vnfmId, @Context HttpServletResponse resp,
 179             @PathParam("vnfInstanceId") String vnfInstanceId, @Context HttpServletRequest context) {
 180         LOG.warn("function=delVnf, msg=enter to delete a vnf: vnfInstanceId: {}, vnfmId: {}", vnfInstanceId, vnfmId);
 181         JSONObject vnfObject = VnfmJsonUtil.getJsonFromContexts(context);
 182         JSONObject restJson = new JSONObject();
 183
 184         if(StringUtils.isEmpty(vnfInstanceId) || StringUtils.isEmpty(vnfmId)) {
 185             resp.setStatus(Constant.HTTP_INNERERROR);
 186             return restJson.toString();
 187         }
 188
 189         restJson = vnfMgr.deleteVnf(vnfInstanceId, vnfmId, vnfObject);
 190         if(restJson.getInt(Constant.RETCODE) == Constant.REST_FAIL) {
 191             LOG.error("function=delVnf, msg=delVnf fail");
 192             resp.setStatus(Constant.HTTP_INNERERROR);
 193             return restJson.toString();
 194         }
 195
 196         return JSONObject.fromObject(restJson.getJSONObject("data")).toString();
 197     }
 198
 199     /**
 200      * Provide function for get VNF
 201      * <br/>
 202      *
 203      * @param vnfmId
 204      * @param resp
 205      * @param vnfInstanceId
 206      * @param context
 207      * @return
 208      * @since VFC 1.0
 209      */
 210     @GET
 211     @Path("/{vnfmId}/vnfs/{vnfInstanceId}")
 212     public String getVnf(@PathParam("vnfmId") String vnfmId, @Context HttpServletResponse resp,
 213             @PathParam("vnfInstanceId") String vnfInstanceId) {
 214         LOG.warn("function=getVnf, msg=enter to get a vnf: vnfInstanceId: {}, vnfmId: {}", vnfInstanceId, vnfmId);
 215         JSONObject restJson = new JSONObject();
 216
 217         if(StringUtils.isEmpty(vnfInstanceId) || StringUtils.isEmpty(vnfmId)) {
 218             resp.setStatus(Constant.HTTP_INNERERROR);
 219             return restJson.toString();
 220         }
 221
 222         restJson = vnfMgr.getVnf(vnfInstanceId, vnfmId);
 223         if(restJson.getInt(Constant.RETCODE) == Constant.REST_FAIL) {
 224             LOG.error("function=getVnf, msg=getVnf fail");
 225             resp.setStatus(Constant.HTTP_INNERERROR);
 226             return restJson.toString();
 227         }
 228
 229         restJson.remove(Constant.RETCODE);
 230         return restJson.toString();
 231     }
 232
 233     /**
 234      * <br>
 235      *
 236      * @param vnfmId
 237      * @param resp
 238      * @return
 239      * @since VFC 1.0
 240      */
 241     @GET
 242     @Path("/{vnfmId}")
 243     public String getVnfmById(@PathParam("vnfmId") String vnfmId, @Context HttpServletResponse resp) {
 244         LOG.warn("function=getVnfmById, vnfmId: {}", vnfmId);
 245         return VnfmUtil.getVnfmById(vnfmId).toString();
 246     }
 247
 248     /**
 249      * Provide function for get job
 250      * <br/>
 251      *
 252      * @param jobId
 253      * @param vnfmId
 254      * @param resp
 255      * @param responseId
 256      * @return
 257      * @since VFC 1.0
 258      */
 259     @GET
 260     @Path("/{vnfmId}/jobs/{jobId}")
 261     public String getJob(@PathParam("jobId") String jobId, @PathParam("vnfmId") String vnfmId,
 262             @Context HttpServletResponse resp, @QueryParam("@responseId") String responseId) {
 263         LOG.warn("function=getJob, msg=enter to get a job: jobId: {}, responseId: {}", jobId, responseId);
 264         JSONObject restJson = new JSONObject();
 265
 266         if(StringUtils.isEmpty(jobId) || StringUtils.isEmpty(vnfmId)) {
 267             resp.setStatus(Constant.HTTP_INNERERROR);
 268             return restJson.toString();
 269         }
 270
 271         restJson = vnfMgr.getJob(jobId, vnfmId);
 272         if(restJson.getInt(Constant.RETCODE) == Constant.REST_FAIL) {
 273             LOG.error("function=getJob, msg=getJob fail");
 274             resp.setStatus(Constant.HTTP_INNERERROR);
 275             return restJson.toString();
 276         }
 277
 278         return getJobBody(restJson);
 279     }
 280
 281     /**
 282      * <br>
 283      *
 284      * @param context
 285      *            {
 286      *            "action": "vmReset",
 287      *            "affectedvm": {
 288      *            "vmid": "804cca71 - 9ae9 - 4511 - 8e30 - d1387718caff",
 289      *            "vduid": "vdu_100",
 290      *            "vmname": "ZTE_SSS_111_PP_2_L"
 291      *            }
 292      *            }
 293      * @param resp
 294      * @param vnfmId
 295      * @param vnfInstanceId
 296      * @return
 297      * @since VFC 1.0
 298      */
 299     @POST
 300     @Path("/{vnfmId}/vnfs/{vnfInstanceId}/heal")
 301     public String healVnf(@Context HttpServletRequest context, @Context HttpServletResponse resp,
 302             @PathParam("vnfmId") String vnfmId, @PathParam("vnfInstanceId") String vnfInstanceId) {
 303         LOG.warn("function=healVnf, msg=enter to heal a vnf: vnfInstanceId: {}, vnfmId: {}", vnfInstanceId, vnfmId);
 304         JSONObject restJson = new JSONObject();
 305         JSONObject jsonObject = VnfmJsonUtil.getJsonFromContexts(context);
 306
 307         if(StringUtils.isEmpty(vnfInstanceId) || StringUtils.isEmpty(vnfmId)) {
 308             resp.setStatus(Constant.HTTP_INNERERROR);
 309             restJson.put("message", "vnfmId is null or vnfInstanceId is null");
 310             return restJson.toString();
 311         }
 312
 313         restJson = vnfMgr.healVnf(jsonObject, vnfInstanceId, vnfmId);
 314         if(restJson.getInt(Constant.RETCODE) == Constant.REST_FAIL) {
 315             LOG.error("function=healVnf, msg=healVnf fail");
 316             resp.setStatus(Constant.HTTP_INNERERROR);
 317             return restJson.toString();
 318         }
 319
 320         restJson.remove(Constant.RETCODE);
 321         restJson.put("jobId", vnfInstanceId + "_post");
 322         return restJson.toString();
 323     }
 324
 325     private String getJobBody(JSONObject restJson) {
 326         LOG.warn("function=getJobBody, restJson: {}", restJson);
 327         JSONObject responseJson = new JSONObject();
 328         JSONObject jobInfoJson = new JSONObject();
 329         JSONObject retJson = restJson.getJSONArray("data").getJSONObject(0);
 330         jobInfoJson.put("jobId", retJson.getString("id"));
 331         responseJson.put("progress", progressItem.get(retJson.getString(Constant.STATUS)));
 332         responseJson.put("status", jobstatusItem.get(retJson.getString(Constant.STATUS)));
 333         responseJson.put("errorCode", "null");
 334         responseJson.put("responseId", progressItem.get(retJson.getString(Constant.STATUS)));
 335         if(retJson.getString(Constant.STATUS) == null || retJson.getString(Constant.STATUS) == "null") {
 336             responseJson.put("progress", "100");
 337             responseJson.put("status", "finished");
 338             responseJson.put("errorCode", "null");
 339             responseJson.put("responseId", "100");
 340         }
 341         jobInfoJson.put("responsedescriptor", responseJson);
 342         LOG.warn("function=getJobBody, jobInfoJson: {}", jobInfoJson);
 343         return jobInfoJson.toString();
 344     }
 345
 346     /**
 347      * <br>
 348      * Query vms info from vnfm
 349      *
 350      * @param vnfmId
 351      * @param resp
 352      * @return
 353      */
 354     @GET
 355     @Path("/{vnfmId}/vms")
 356     public String getVms(@PathParam("vnfmId") String vnfmId, @Context HttpServletResponse resp) {
 357         LOG.info("function=getVms, msg=enter to get vms: vnfmId: {}", vnfmId);
 358         JSONObject restJson = vnfMgr.getVmsFromVnfm(vnfmId, null);
 359         LOG.info("function=getVms, restJson: {}", restJson);
 360         return restJson.getString("data");
 361     }
 362
 363     /**
 364      * <br>
 365      * Query vms info by vnfId from vnfm
 366      *
 367      * @param vnfmId
 368      * @param vnfInstanceId
 369      * @param resp
 370      * @return
 371      */
 372     @GET
 373     @Path("/{vnfmId}/{vnfInstanceId}/vms")
 374     public String getVmsByVnfId(@PathParam("vnfmId") String vnfmId, @PathParam("vnfInstanceId") String vnfInstanceId,
 375             @Context HttpServletResponse resp) {
 376         LOG.info("function=getVmsByVnfId, msg=enter to get vms: vnfmId: {}", vnfmId);
 377         JSONObject restJson = vnfMgr.getVmsFromVnfm(vnfmId, vnfInstanceId);
 378         LOG.info("function=getVmsByVnfId, restJson: {}", restJson);
 379         return restJson.getString("data");
 380     }
 381
 382     /**
 383      * <br>
 384      * Query job status from vnfm version 18.1
 385      *
 386      * @param jobId
 387      * @param vnfmId
 388      * @param responseId
 389      * @return
 390      * @since VFC 1.0
 391      */
 392     public String getJobFromVnfm(@PathParam("jobId") String jobId, @PathParam("vnfmId") String vnfmId,
 393             @Context HttpServletResponse resp, @QueryParam("@responseId") String responseId) {
 394         LOG.warn("function=getJobFromVnfm, msg=enter to get a job: jobId: {}, responseId: {}", jobId, responseId);
 395         JSONObject restJson = vnfMgr.getJobFromVnfm(jobId, vnfmId);
 396
 397         if(restJson.getInt(Constant.RETCODE) == Constant.REST_FAIL) {
 398             LOG.error("function=getJobFromVnfm, msg=getJobFromVnfm fail");
 399             resp.setStatus(Constant.HTTP_INNERERROR);
 400             return restJson.toString();
 401         }
 402
 403         return vnfMgr.transferToLcm(restJson);
 404     }
 405 }