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.io.IOException;
  20 import java.util.HashMap;
  21 import java.util.Map;
  22
  23 import javax.servlet.http.HttpServletRequest;
  24 import javax.servlet.http.HttpServletResponse;
  25 import javax.ws.rs.Consumes;
  26 import javax.ws.rs.GET;
  27 import javax.ws.rs.POST;
  28 import javax.ws.rs.Path;
  29 import javax.ws.rs.PathParam;
  30 import javax.ws.rs.Produces;
  31 import javax.ws.rs.QueryParam;
  32 import javax.ws.rs.core.Context;
  33 import javax.ws.rs.core.MediaType;
  34
  35 import org.apache.commons.collections.map.UnmodifiableMap;
  36 import org.apache.commons.lang3.StringUtils;
  37 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.common.VnfmJsonUtil;
  38 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.common.VnfmUtil;
  39 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.service.constant.Constant;
  40 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.service.process.VnfMgr;
  41 import org.slf4j.Logger;
  42 import org.slf4j.LoggerFactory;
  43
  44 import net.sf.json.JSONObject;
  45
  46 /**
  47  * Provide interfaces for instantiate or terminate VNF.
  48  * <br/>
  49  *
  50  * @author
  51  * @version VFC 1.0 Aug 24, 2016
  52  */
  53 @SuppressWarnings("unchecked")
  54 @Path("/api/huaweivnfmdriver/v1")
  55 @Consumes(MediaType.APPLICATION_JSON)
  56 @Produces(MediaType.APPLICATION_JSON)
  57 public class VnfRoa {
  58
  59     private static final Logger LOG = LoggerFactory.getLogger(VnfRoa.class);
  60
  61     private VnfMgr vnfMgr;
  62
  63     private static Map<String, String> progressItem;
  64
  65     private static Map<String, String> jobstatusItem;
  66
  67     static {
  68         Map<String, String> map = new HashMap<>();
  69         map.put("Building", "50");
  70         map.put("Active", "100");
  71         map.put("Stopped", "50");
  72         map.put("Error", "100");
  73         progressItem = UnmodifiableMap.decorate(map);
  74
  75         map = new HashMap<>();
  76         map.put("Building", "processing");
  77         map.put("Active", "finished");
  78         map.put("Stopped", "processing");
  79         map.put("Error", "error");
  80         jobstatusItem = UnmodifiableMap.decorate(map);
  81     }
  82
  83     public void setVnfMgr(VnfMgr vnfMgr) {
  84         this.vnfMgr = vnfMgr;
  85     }
  86
  87     /**
  88      * Scale VNF
  89      *
  90      * @param vnfmId
  91      * @param vnfInstanceId
  92      * @param resp
  93      * @param context
  94      *            {
  95      *            "vnfInstanceId":"5",
  96      *            "type":"SCALE_OUT",
  97      *            "aspectId":"101",
  98      *            "numberOfSteps":"1",
  99      *            "additionalParam":{}
 100      *            }
 101      * @return
 102      *         {
 103      *         "jobId":"1"
 104      *         }
 105      */
 106     @POST
 107     @Path("/{vnfmId}/vnfs/{vnfInstanceId}/scale")
 108     public String scaleVnf(@Context HttpServletRequest context, @Context HttpServletResponse resp,
 109             @PathParam("vnfmId") String vnfmId, @PathParam("vnfInstanceId") String vnfInstanceId) {
 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         if(null == jsonObject) {
 114             String msg = "the parameters do not meet the requirements,please check it!";
 115             LOG.error("function=scalVnf," + msg);
 116             resp.setStatus(Constant.HTTP_NOT_ACCEPTABLE);
 117             result.put("msg", msg);
 118             return result.toString();
 119         }
 120
 121         result = vnfMgr.scaleVNF(jsonObject, vnfmId, vnfInstanceId);
 122         LOG.info("function=scaleVNF,result=" + result.toString());
 123         if(result.getInt(Constant.RETCODE) == Constant.REST_FAIL) {
 124             LOG.error("function=scaleVNF, msg=scaleVnf fail");
 125             resp.setStatus(Constant.HTTP_INNERERROR);
 126             return result.toString();
 127         }
 128         return JSONObject.fromObject(result.getJSONObject("data")).toString();
 129     }
 130
 131     /**
 132      * Provide function for instantiate VNF
 133      * <br/>
 134      *
 135      * @param context
 136      * @param resp
 137      * @param vnfmId
 138      * @return
 139      * @since VFC 1.0
 140      */
 141     @POST
 142     @Path("/{vnfmId}/vnfs")
 143     public String addVnf(@Context HttpServletRequest context, @Context HttpServletResponse resp,
 144             @PathParam("vnfmId") String vnfmId) {
 145         LOG.warn("function=addVnf, msg=enter to add a vnf");
 146         JSONObject subJsonObject = VnfmJsonUtil.getJsonFromContexts(context);
 147         JSONObject restJson = new JSONObject();
 148
 149         if(null == subJsonObject) {
 150             LOG.error("function=addVnf, msg=params are insufficient");
 151             resp.setStatus(Constant.HTTP_INNERERROR);
 152             return restJson.toString();
 153         }
 154         LOG.info("addVnf request info from (LCM):" + subJsonObject);
 155         restJson = vnfMgr.addVnf(subJsonObject, vnfmId);
 156
 157         if(restJson.getInt(Constant.RETCODE) == Constant.REST_FAIL) {
 158             LOG.error("function=addVnf, msg=addvnf fail");
 159             resp.setStatus(Constant.HTTP_INNERERROR);
 160             return restJson.toString();
 161         }
 162
 163         return JSONObject.fromObject(restJson.getJSONObject("data")).toString();
 164     }
 165
 166     /**
 167      * Provide function for terminate VNF
 168      * <br/>
 169      *
 170      * @param vnfmId
 171      * @param resp
 172      * @param vnfInstanceId
 173      * @param context
 174      * @return
 175      * @since VFC 1.0
 176      */
 177     @POST
 178     @Path("/{vnfmId}/vnfs/{vnfInstanceId}/terminate")
 179     public String delVnf(@PathParam("vnfmId") String vnfmId, @Context HttpServletResponse resp,
 180             @PathParam("vnfInstanceId") String vnfInstanceId, @Context HttpServletRequest context) {
 181         LOG.warn("function=delVnf, msg=enter to delete a vnf: vnfInstanceId: {}, vnfmId: {}", vnfInstanceId, vnfmId);
 182         JSONObject vnfObject = VnfmJsonUtil.getJsonFromContexts(context);
 183         JSONObject restJson = new JSONObject();
 184
 185         if(StringUtils.isEmpty(vnfInstanceId) || StringUtils.isEmpty(vnfmId)) {
 186             resp.setStatus(Constant.HTTP_INNERERROR);
 187             return restJson.toString();
 188         }
 189
 190         restJson = vnfMgr.deleteVnf(vnfInstanceId, vnfmId, vnfObject);
 191         if(restJson.getInt(Constant.RETCODE) == Constant.REST_FAIL) {
 192             LOG.error("function=delVnf, msg=delVnf fail");
 193             resp.setStatus(Constant.HTTP_INNERERROR);
 194             return restJson.toString();
 195         }
 196
 197         return JSONObject.fromObject(restJson.getJSONObject("data")).toString();
 198     }
 199
 200     /**
 201      * Provide function for get VNF
 202      * <br/>
 203      *
 204      * @param vnfmId
 205      * @param resp
 206      * @param vnfInstanceId
 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) throws IOException {
 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         LOG.info("function=getVnf, restJson: {}", restJson);
 231         return restJson.toString();
 232     }
 233
 234     /**
 235      * <br>
 236      *
 237      * @param vnfmId
 238      * @param resp
 239      * @return
 240      * @since VFC 1.0
 241      */
 242     @GET
 243     @Path("/{vnfmId}")
 244     public String getVnfmById(@PathParam("vnfmId") String vnfmId, @Context HttpServletResponse resp) {
 245         LOG.warn("function=getVnfmById, vnfmId: {}", vnfmId);
 246         return VnfmUtil.getVnfmById(vnfmId).toString();
 247     }
 248
 249     /**
 250      * Provide function for get job
 251      * <br/>
 252      *
 253      * @param jobId
 254      * @param vnfmId
 255      * @param resp
 256      * @param responseId
 257      * @return
 258      * @since VFC 1.0
 259      */
 260     @GET
 261     @Path("/{vnfmId}/jobs_old/{jobId}")
 262     public String getJob(@PathParam("jobId") String jobId, @PathParam("vnfmId") String vnfmId,
 263             @Context HttpServletResponse resp, @QueryParam("@responseId") String responseId) {
 264         LOG.warn("function=getJob, msg=enter to get a job: jobId: {}, responseId: {}", jobId, responseId);
 265         return getJob(jobId, vnfmId, resp);
 266     }
 267
 268     /**
 269      * <br>
 270      * common getJob method
 271      *
 272      * @param jobId
 273      * @param vnfmId
 274      * @param resp
 275      * @return
 276      * @since VFC 1.0
 277      */
 278     private String getJob(String jobId, String vnfmId, HttpServletResponse resp) {
 279         JSONObject restJson = new JSONObject();
 280
 281         if(StringUtils.isEmpty(jobId) || StringUtils.isEmpty(vnfmId)) {
 282             resp.setStatus(Constant.HTTP_INNERERROR);
 283             return restJson.toString();
 284         }
 285
 286         restJson = vnfMgr.getJob(jobId, vnfmId);
 287         if(restJson.getInt(Constant.RETCODE) == Constant.REST_FAIL) {
 288             LOG.error("function=getJob, msg=getJob fail");
 289             resp.setStatus(Constant.HTTP_INNERERROR);
 290             return restJson.toString();
 291         }
 292
 293         return getJobBody(restJson, jobId);
 294     }
 295
 296     /**
 297      * <br>
 298      *
 299      * @param context
 300      *            {
 301      *            "action": "vmReset",
 302      *            "affectedvm": {
 303      *            "vmid": "804cca71 - 9ae9 - 4511 - 8e30 - d1387718caff",
 304      *            "vduid": "vdu_100",
 305      *            "vmname": "ZTE_SSS_111_PP_2_L"
 306      *            }
 307      *            }
 308      * @param resp
 309      * @param vnfmId
 310      * @param vnfInstanceId
 311      * @return
 312      * @since VFC 1.0
 313      */
 314     @POST
 315     @Path("/{vnfmId}/vnfs/{vnfInstanceId}/heal")
 316     public String healVnf(@Context HttpServletRequest context, @Context HttpServletResponse resp,
 317             @PathParam("vnfmId") String vnfmId, @PathParam("vnfInstanceId") String vnfInstanceId) {
 318         LOG.warn("function=healVnf, msg=enter to heal a vnf: vnfInstanceId: {}, vnfmId: {}", vnfInstanceId, vnfmId);
 319         JSONObject restJson = new JSONObject();
 320         JSONObject jsonObject = VnfmJsonUtil.getJsonFromContexts(context);
 321
 322         if(StringUtils.isEmpty(vnfInstanceId) || StringUtils.isEmpty(vnfmId)) {
 323             resp.setStatus(Constant.HTTP_INNERERROR);
 324             restJson.put("message", "vnfmId is null or vnfInstanceId is null");
 325             return restJson.toString();
 326         }
 327
 328         restJson = vnfMgr.healVnf(jsonObject, vnfInstanceId, vnfmId);
 329         if(restJson.getInt(Constant.RETCODE) == Constant.REST_FAIL) {
 330             LOG.error("function=healVnf, msg=healVnf fail");
 331             resp.setStatus(Constant.HTTP_INNERERROR);
 332             return restJson.toString();
 333         }
 334
 335         restJson.remove(Constant.RETCODE);
 336         restJson.put("jobId", vnfInstanceId + "_post");
 337         return restJson.toString();
 338     }
 339
 340     private String getJobBody(JSONObject restJson, String jobId) {
 341         LOG.warn("function=getJobBody, restJson: {}", restJson);
 342         JSONObject responseJson = new JSONObject();
 343         JSONObject jobInfoJson = new JSONObject();
 344         JSONObject retJson = restJson.getJSONArray("data").getJSONObject(0);
 345         jobInfoJson.put("jobId", jobId);
 346         responseJson.put("progress", progressItem.get(retJson.getString(Constant.STATUS)));
 347         responseJson.put("status", jobstatusItem.get(retJson.getString(Constant.STATUS)));
 348         responseJson.put("errorCode", "null");
 349         responseJson.put("responseId", progressItem.get(retJson.getString(Constant.STATUS)));
 350         if(retJson.getString(Constant.STATUS) == null || retJson.getString(Constant.STATUS) == "null") {
 351             responseJson.put("progress", "100");
 352             responseJson.put("status", "finished");
 353             responseJson.put("errorCode", "null");
 354             responseJson.put("responseId", "100");
 355         }
 356         jobInfoJson.put("responsedescriptor", responseJson);
 357         LOG.warn("function=getJobBody, jobInfoJson: {}", jobInfoJson);
 358         return jobInfoJson.toString();
 359     }
 360
 361     /**
 362      * <br>
 363      * Query vms info from vnfm
 364      *
 365      * @param vnfmId
 366      * @param resp
 367      * @return
 368      */
 369     @GET
 370     @Path("/{vnfmId}/vms")
 371     public String getVms(@PathParam("vnfmId") String vnfmId, @Context HttpServletResponse resp) {
 372         LOG.info("function=getVms, msg=enter to get vms: vnfmId: {}", vnfmId);
 373         JSONObject restJson = vnfMgr.getVmsFromVnfm(vnfmId, null);
 374         LOG.info("function=getVms, restJson: {}", restJson);
 375         return restJson.getString("data");
 376     }
 377
 378     /**
 379      * <br>
 380      * Query vms info by vnfId from vnfm
 381      *
 382      * @param vnfmId
 383      * @param vnfInstanceId
 384      * @param resp
 385      * @return
 386      */
 387     @GET
 388     @Path("/{vnfmId}/{vnfInstanceId}/vms")
 389     public String getVmsByVnfId(@PathParam("vnfmId") String vnfmId, @PathParam("vnfInstanceId") String vnfInstanceId,
 390             @Context HttpServletResponse resp) {
 391         LOG.info("function=getVmsByVnfId, msg=enter to get vms: vnfmId: {}", vnfmId);
 392         JSONObject restJson = vnfMgr.getVmsFromVnfm(vnfmId, vnfInstanceId);
 393         LOG.info("function=getVmsByVnfId, restJson: {}", restJson);
 394         return restJson.getString("data");
 395     }
 396
 397     /**
 398      * <br>
 399      * Query job status from vnfm version 18.1
 400      *
 401      * @param jobId
 402      * @param vnfmId
 403      * @param responseId
 404      * @return
 405      * @since VFC 1.0
 406      */
 407     @GET
 408     @Path("/{vnfmId}/jobs/{jobId}")
 409     public String getJobFromVnfm(@PathParam("jobId") String jobId, @PathParam("vnfmId") String vnfmId,
 410             @Context HttpServletResponse resp, @QueryParam("@responseId") String responseId) {
 411         LOG.warn("function=getJobFromVnfm, msg=enter to get a job: jobId: {}, responseId: {}", jobId, responseId);
 412         String[] temps = jobId.split(":");
 413         String tmpJobId = temps[0];
 414         String flag = temps[1];
 415         LOG.warn("function=getJobFromVnfm, tmpJobId: {}, flag: {}", tmpJobId, flag);
 416
 417         if(flag.equalsIgnoreCase("no")) {
 418             return getJob(tmpJobId, vnfmId, resp);
 419         } else {
 420             JSONObject restJson = vnfMgr.getJobFromVnfm(tmpJobId, vnfmId);
 421
 422             if(restJson.getInt(Constant.RETCODE) == Constant.REST_FAIL) {
 423                 LOG.error("function=getJobFromVnfm, msg=getJobFromVnfm fail");
 424                 resp.setStatus(Constant.HTTP_INNERERROR);
 425                 return restJson.toString();
 426             }
 427
 428             return vnfMgr.transferToLcm(restJson);
 429         }
 430     }
 431 }