huawei/vnfmadapter/VnfmadapterService/service/src/main/java/org/onap/vfc/nfvo/vnfm/svnfm/vnfmadapter/service/process/VnfMgr.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.process;
  18
  19 import java.io.IOException;
  20 import java.util.Map;
  21 import java.util.concurrent.ConcurrentHashMap;
  22
  23 import org.apache.commons.lang3.StringUtils;
  24 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.common.ResultRequestUtil;
  25 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.common.VnfmUtil;
  26 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.service.adapter.impl.AdapterResourceManager;
  27 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.service.constant.Constant;
  28 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.service.csm.vnf.VnfMgrVnfm;
  29 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.service.dao.inf.VnfmDao;
  30 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.service.entity.Vnfm;
  31 import org.slf4j.Logger;
  32 import org.slf4j.LoggerFactory;
  33
  34 import net.sf.json.JSONException;
  35 import net.sf.json.JSONObject;
  36
  37 /**
  38  * Provide function for instantiate or terminate VNF
  39  * <br/>
  40  *
  41  * @author
  42  * @version VFC 1.0 Aug 24, 2016
  43  */
  44 public class VnfMgr {
  45
  46     private static final Logger LOG = LoggerFactory.getLogger(VnfMgr.class);
  47
  48     private VnfmDao vnfmDao;
  49
  50     public void setVnfmDao(VnfmDao vnfmDao) {
  51         this.vnfmDao = vnfmDao;
  52     }
  53
  54     private String configedVduType;
  55
  56
  57     /**
  58      * @param configedVduType The configedVduType to set.
  59      */
  60     public void setConfigedVduType(String configedVduType) {
  61         this.configedVduType = configedVduType;
  62     }
  63
  64     /**
  65      * Scale vnf
  66      *
  67      * @param vnfObject
  68      *            {
  69      *            "vnfInstanceId":"5",
  70      *            "type":"SCALE_OUT",
  71      *            "aspectId":"101",
  72      *            "numberOfSteps":"1",
  73      *            "additionalParam":{}
  74      *            }
  75      * @param vnfmId
  76      * @param vnfInstanceId
  77      * @return
  78      */
  79     public JSONObject scaleVNF(JSONObject vnfObject, String vnfmId, String vnfInstanceId) {
  80         JSONObject restJson = new JSONObject();
  81         restJson.put(Constant.RETCODE, Constant.REST_FAIL);
  82         try {
  83
  84             if(vnfObject.isNullObject() || vnfObject.isEmpty()) {
  85                 return restJson;
  86             }
  87
  88             JSONObject vnfmObjcet = VnfmUtil.getVnfmById(vnfmId);
  89             LOG.info("vnfm info:" + vnfmObjcet);
  90             if(vnfmObjcet.isNullObject()) {
  91                 LOG.error("function=scaleVNF,can't find vnfm from db by vnfmId=" + vnfmId);
  92                 return restJson;
  93             }
  94             if(StringUtils.isNotEmpty(configedVduType)) {
  95                 vnfObject.put("configedVduType", configedVduType);
  96             }
  97             restJson = (new VnfMgrVnfm()).scaleVnf(vnfObject, vnfmObjcet, vnfmId, vnfInstanceId);
  98         } catch(JSONException e) {
  99             LOG.error("function=scaleVNF, msg=JSONException occurs, e={}.", e);
 100         }
 101
 102         return restJson;
 103     }
 104
 105     /**
 106      * Provide function for instantiate VNF
 107      * <br/>
 108      *
 109      * @param vnfObject
 110      * @param vnfmId
 111      * @return
 112      * @since VFC 1.0
 113      */
 114     public JSONObject addVnf(JSONObject vnfObject, String vnfmId) {
 115         JSONObject restJson = new JSONObject();
 116         restJson.put(Constant.RETCODE, Constant.REST_FAIL);
 117         try {
 118
 119             if(vnfObject.isNullObject() || vnfObject.isEmpty()) {
 120                 return restJson;
 121             }
 122
 123             JSONObject vnfmObjcet = VnfmUtil.getVnfmById(vnfmId);
 124
 125             if(vnfmObjcet.isNullObject()) {
 126                 return restJson;
 127             }
 128
 129             Map<String, String> conMap = new ConcurrentHashMap<>(Constant.DEFAULT_COLLECTION_SIZE);
 130             conMap.put("csarid", vnfObject.getString("vnfPackageId"));
 131             conMap.put("vnfmid", vnfmId);
 132             conMap.put("vnfDescriptorId", vnfObject.getString("vnfDescriptorId"));
 133
 134             JSONObject resObjcet = (new AdapterResourceManager()).uploadVNFPackage(null, conMap);
 135
 136             if(resObjcet.getInt(Constant.RETCODE) == Constant.REST_FAIL) {
 137                 return restJson;
 138             }
 139
 140             JSONObject csmBody = transferVnfBody(vnfObject, resObjcet, vnfmId);
 141             restJson = (new VnfMgrVnfm()).createVnf(csmBody, vnfmObjcet);
 142             saveVnfInfo(restJson, resObjcet);
 143         } catch(JSONException e) {
 144             LOG.error("function=addVnf, msg=JSONException occurs, e={}.", e);
 145         }
 146
 147         return restJson;
 148     }
 149
 150     /**
 151      * Provide function for terminate VNF
 152      * <br/>
 153      *
 154      * @param vnfId
 155      * @param vnfmId
 156      * @param vnfObject
 157      * @return
 158      * @since VFC 1.0
 159      */
 160     public JSONObject deleteVnf(String vnfId, String vnfmId, JSONObject vnfObject) {
 161         LOG.warn("function=deleteVnf ,msg=enter to delete a vnf, vnfId:{}, vnfmId:{}", vnfId, vnfmId);
 162         JSONObject restJson = new JSONObject();
 163         restJson.put(Constant.RETCODE, Constant.REST_FAIL);
 164         try {
 165             JSONObject vnfmObjcet = VnfmUtil.getVnfmById(vnfmId);
 166             if(vnfmObjcet.isNullObject()) {
 167                 LOG.error("function=deleteVnf, msg=vnfm not exists, vnfmId: {}", vnfmId);
 168                 return restJson;
 169             }
 170
 171             restJson = (new VnfMgrVnfm()).removeVnf(vnfmObjcet, vnfId, vnfObject);
 172         } catch(JSONException e) {
 173             LOG.error("function=deleteVnf, msg=JSONException occurs, e={}.", e);
 174         }
 175         return restJson;
 176     }
 177
 178     /**
 179      * Provide function for get VNF
 180      * <br/>
 181      *
 182      * @param vnfId
 183      * @param vnfmId
 184      * @return
 185      * @since VFC 1.0
 186      */
 187     public JSONObject getVnf(String vnfId, String vnfmId) throws IOException {
 188         LOG.warn("function=getVnf ,msg=enter to get a vnf, vnfId:{}, vnfmId:{}", vnfId, vnfmId);
 189         JSONObject restJson = new JSONObject();
 190         restJson.put(Constant.RETCODE, Constant.REST_FAIL);
 191         try {
 192             JSONObject vnfmObjcet = VnfmUtil.getVnfmById(vnfmId);
 193             if(vnfmObjcet.isNullObject()) {
 194                 LOG.error("function=getVnf, msg=vnfm not exists, vnfmId: {}", vnfmId);
 195                 return restJson;
 196             }
 197
 198             restJson = (new VnfMgrVnfm()).getVnf(vnfmObjcet, vnfId);
 199             JSONObject ipObj = (new VnfMgrVnfm()).getIp(vnfmObjcet, vnfId);
 200
 201             return restJson.getInt(Constant.RETCODE) == Constant.REST_FAIL ? restJson : getVnfBody(restJson, ipObj);
 202
 203         } catch(JSONException e) {
 204             LOG.error("function=getVnf, msg=JSONException occurs, e={}.", e);
 205             restJson.put(Constant.RETCODE, Constant.REST_FAIL);
 206         }
 207         return restJson;
 208     }
 209
 210     private JSONObject getVnfBody(JSONObject restJson, JSONObject ipObj) {
 211         try {
 212             JSONObject vnfInfoJson = new JSONObject();
 213             JSONObject basicInfoJson = new JSONObject();
 214
 215             JSONObject retJson = restJson.getJSONArray("data").getJSONObject(0);
 216
 217             basicInfoJson.put("vnfInstanceId", retJson.getString("vnf_id"));
 218             basicInfoJson.put("vnfInstanceName", retJson.getString("vnf_name"));
 219             basicInfoJson.put("vnfInstanceDescription", "");
 220
 221             basicInfoJson.put(Constant.VNFDID, retJson.getString("vnfd_id"));
 222             basicInfoJson.put("vnfdPackageId", retJson.getString("vnfd_id"));
 223             basicInfoJson.put("version", "1.0");
 224             basicInfoJson.put("vnfProvider", "hw");
 225             basicInfoJson.put("vnfType", retJson.get("vnf_type"));
 226             basicInfoJson.put("vnfStatus", retJson.getString(Constant.STATUS));
 227             if(ipObj.getInt(Constant.RETCODE) == Constant.REST_SUCCESS) {
 228                 basicInfoJson.put("ipInfo", ipObj.getJSONObject("data"));
 229             }
 230             vnfInfoJson.put("vnfInfo", basicInfoJson);
 231             vnfInfoJson.put(Constant.RETCODE, Constant.REST_SUCCESS);
 232             return vnfInfoJson;
 233         } catch(JSONException e) {
 234             LOG.error("function=getVnf, msg=JSONException occurs, e={}.", e);
 235             restJson.put(Constant.RETCODE, Constant.REST_FAIL);
 236             return restJson;
 237         } catch(IndexOutOfBoundsException e) {
 238             LOG.error("function=getVnf, msg=IndexOutOfBoundsException occurs, e={}.", e);
 239             restJson.put(Constant.RETCODE, Constant.REST_FAIL);
 240             return restJson;
 241         }
 242     }
 243
 244     @SuppressWarnings("unchecked")
 245     private JSONObject transferVnfBody(JSONObject vnfObject, JSONObject resObject, String vnfmId) {
 246         JSONObject restJson = new JSONObject();
 247         JSONObject vappIfno = new JSONObject();
 248         restJson.put("vnfd_id", resObject.getString(Constant.VNFDID));
 249         restJson.put("plan_id", resObject.getOrDefault("planId", ""));
 250         restJson.put("plan_name", resObject.getOrDefault("planName", ""));
 251         restJson.put("vapp_name", vnfObject.get("vnfInstanceName"));
 252         restJson.put("project_id", vnfmId);
 253         restJson.put("parameters", resObject.getJSONObject("parameters"));
 254         if(resObject.containsKey("emsUuid")) {
 255             restJson.put("emsUuid", resObject.getString("emsUuid"));
 256         }
 257         restJson.put("nfvo_id", "");
 258         restJson.put("location", "");
 259         restJson.put("vnfm_id", vnfmId);
 260         vappIfno.put("vapp_info", restJson);
 261         return vappIfno;
 262     }
 263
 264     /**
 265      * Provide function for get job
 266      * <br/>
 267      *
 268      * @param jobId
 269      * @param vnfmId
 270      * @return
 271      * @since VFC 1.0
 272      */
 273     public JSONObject getJob(String jobId, String vnfmId) {
 274         LOG.warn("function=getJob ,msg=enter to get a job, vnfId:{}", jobId);
 275         JSONObject restJson = new JSONObject();
 276         restJson.put(Constant.RETCODE, Constant.REST_FAIL);
 277         try {
 278             JSONObject vnfmObjcet = VnfmUtil.getVnfmById(vnfmId);
 279             if(vnfmObjcet.isNullObject()) {
 280                 LOG.error("function=getJob, msg=vnfm not exists, vnfmId: {}", vnfmId);
 281                 return restJson;
 282             }
 283
 284             restJson = (new VnfMgrVnfm()).getJob(vnfmObjcet, jobId);
 285
 286         } catch(JSONException e) {
 287             LOG.error("function=getJob, msg=JSONException occurs, e={}.", e);
 288             restJson.put(Constant.RETCODE, Constant.REST_FAIL);
 289         }
 290         return restJson;
 291     }
 292
 293     /**
 294      * Provide function for save vnfInfo
 295      * <br/>
 296      *
 297      * @param vnfObject
 298      * @param resObject
 299      * @since VFC 1.0
 300      */
 301     public void saveVnfInfo(JSONObject vnfObject, JSONObject resObject) {
 302         LOG.warn("function=saveVnfInfo , vnfObject:{}", vnfObject);
 303         if(vnfObject.getInt(Constant.RETCODE) == Constant.REST_SUCCESS) {
 304             Vnfm info = new Vnfm();
 305             info.setId(vnfObject.getJSONObject("data").getString("vnfInstanceId"));
 306             info.setVersion(resObject.getString("vnfdVersion"));
 307             info.setVnfdId(resObject.getString(Constant.VNFDID));
 308             info.setVnfPackageId("");
 309             try {
 310                 vnfmDao.insertVnfm(info);
 311             } catch(Exception e) {
 312                 LOG.error("function=saveVnfInfo, msg=ServiceException occurs, e={}.", e);
 313             }
 314         }
 315     }
 316
 317     /**
 318      * <br>
 319      *
 320      * @param jsonObject
 321      * @param vnfInstanceId
 322      * @param vnfmId
 323      * @return
 324      * @since VFC 1.0
 325      */
 326     public JSONObject healVnf(JSONObject jsonObject, String vnfInstanceId, String vnfmId) {
 327         JSONObject restJson = new JSONObject();
 328         restJson.put(Constant.RETCODE, Constant.REST_FAIL);
 329
 330         if(jsonObject.isNullObject() || jsonObject.isEmpty()) {
 331             return restJson;
 332         }
 333
 334         JSONObject vnfmObjcet = VnfmUtil.getVnfmById(vnfmId);
 335         LOG.info("vnfm info:" + vnfmObjcet);
 336         if(vnfmObjcet.isNullObject()) {
 337             LOG.error("function=scaleVNF,can't find vnfm from db by vnfmId=" + vnfmId);
 338             return restJson;
 339         }
 340         restJson = (new VnfMgrVnfm()).healVnf(jsonObject, vnfmObjcet, vnfmId, vnfInstanceId);
 341         return restJson;
 342     }
 343
 344     public JSONObject getJobFromVnfm(String jobId, String vnfmId) {
 345         LOG.warn("function=getJobFromVnfm, jobId:{}, vnfmId:{}", jobId, vnfmId);
 346         JSONObject restJson = new JSONObject();
 347         JSONObject vnfmObjcet = VnfmUtil.getVnfmById(vnfmId);
 348         if(vnfmObjcet.isNullObject()) {
 349             LOG.error("function=getJobFromVnfm, msg=vnfm not exists, vnfmId: {}", vnfmId);
 350             return restJson;
 351         }
 352         restJson = (new VnfMgrVnfm()).getJobFromVnfm(vnfmObjcet, jobId);
 353         return restJson;
 354     }
 355
 356     public String transferToLcm(JSONObject restJson) {
 357         LOG.warn("function=transferToLcm, restJson: {}", restJson);
 358         JSONObject responseJson = new JSONObject();
 359         JSONObject jobInfoJson = new JSONObject();
 360         JSONObject jobInfo = restJson.getJSONObject("data").getJSONObject("job_info");
 361         jobInfoJson.put("jobId", jobInfo.getString("job_id") + ":job");
 362         responseJson.put("progress", jobInfo.getString("task_progress_rate"));
 363
 364         String taskStatus = jobInfo.getString("task_status");
 365         if(taskStatus.equalsIgnoreCase("Successfully") || taskStatus.equalsIgnoreCase("finished")) {
 366             responseJson.put("status", "finished");
 367         } else if(taskStatus.equalsIgnoreCase("Failed")) {
 368             responseJson.put("status", "error");
 369         } else {
 370             responseJson.put("status", "processing");
 371         }
 372         responseJson.put("errorCode", jobInfo.getString("error_code"));
 373         responseJson.put("responseId", jobInfo.getString("task_progress_rate"));
 374         jobInfoJson.put("responsedescriptor", responseJson);
 375         LOG.warn("function=getJobBody, jobInfoJson: {}", jobInfoJson);
 376         return jobInfoJson.toString();
 377     }
 378
 379     public JSONObject getVmsFromVnfm(String vnfmId, String vnfInstanceId) {
 380         JSONObject restJson = new JSONObject();
 381         JSONObject vnfmObjcet = VnfmUtil.getVnfmById(vnfmId);
 382         if(vnfmObjcet.isNullObject()) {
 383             LOG.error("function=getVmsFromVnfm, msg=vnfm not exists, vnfmId: {}", vnfmId);
 384             restJson.put("message", "vnfm not exists");
 385             return restJson;
 386         }
 387         String url = "";
 388         if(vnfInstanceId == null) {
 389             url = "/v2/vapps/instances/query/vms";
 390         } else {
 391             url = String.format("/v2/vapps/instances/%s/vm", vnfInstanceId);
 392         }
 393         restJson = ResultRequestUtil.call(vnfmObjcet, url, Constant.GET, null, Constant.CERTIFICATE);
 394         LOG.info("function=getVmsFromVnfm, restJson: {}", restJson);
 395         return restJson;
 396     }
 397
 398 }