huawei/vnfmadapter/VnfmadapterService/service/src/main/java/org/onap/vfc/nfvo/vnfm/svnfm/vnfmadapter/service/adapter/impl/AdapterResourceManager.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.adapter.impl;
  18
  19 import java.io.BufferedInputStream;
  20 import java.io.File;
  21 import java.io.FileInputStream;
  22 import java.io.FileNotFoundException;
  23 import java.io.IOException;
  24 import java.io.InputStream;
  25 import java.util.HashMap;
  26 import java.util.Map;
  27
  28 import org.apache.commons.httpclient.HttpMethod;
  29 import org.apache.commons.httpclient.HttpStatus;
  30 import org.apache.commons.net.ftp.FTPClient;
  31 import org.apache.commons.net.ftp.FTPReply;
  32 import org.apache.commons.net.ftp.FTPSClient;
  33 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.common.DownloadCsarManager;
  34 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.common.VnfmException;
  35 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.common.restclient.RestfulResponse;
  36 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.common.restclient.SystemEnvVariablesFactory;
  37 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.common.servicetoken.VNFRestfulUtil;
  38 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.service.adapter.inf.IResourceManager;
  39 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.service.constant.Constant;
  40 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.service.constant.UrlConstant;
  41 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.service.csm.connect.ConnectMgrVnfm;
  42 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.service.csm.connect.HttpRequests;
  43 import org.slf4j.Logger;
  44 import org.slf4j.LoggerFactory;
  45
  46 import net.sf.json.JSONArray;
  47 import net.sf.json.JSONException;
  48 import net.sf.json.JSONObject;
  49
  50 /**
  51  * Resource Manager adapter class.
  52  * .</br>
  53  *
  54  * @author
  55  * @version VFC 1.0 Sep 13, 2016
  56  */
  57 public class AdapterResourceManager implements IResourceManager {
  58
  59     private static final Logger LOG = LoggerFactory.getLogger(AdapterResourceManager.class);
  60
  61     private static final String VNFD_FILE_PATH = "vnfd_file_path";
  62
  63     @Override
  64     public JSONObject uploadVNFPackage(JSONObject vnfpkg, Map<String, String> paramsMap) {
  65         JSONObject resultObj = new JSONObject();
  66         String vnfDescriptorId = paramsMap.get("vnfDescriptorId");
  67         try {
  68             // if upper layer do not provide vnfpackage info,then get the
  69             // vnfpackage info from JSON file.
  70             if(vnfpkg == null || vnfpkg.isEmpty()) {
  71                 String vnfPkgInfo = readVfnPkgInfoFromJson();
  72                 JSONObject vnfpkgJson = JSONObject.fromObject(vnfPkgInfo);
  73                 vnfpkg = vnfpkgJson.getJSONObject(vnfDescriptorId);
  74             }
  75         } catch(IOException e) {
  76             LOG.error("function=uploadVNFPackage", e);
  77         }
  78
  79         // check if parameters are null.
  80         if(paramsMap == null || paramsMap.isEmpty()) {
  81             resultObj.put(Constant.REASON, "csarid and vnfmid are null.");
  82             resultObj.put(Constant.RETCODE, Constant.REST_FAIL);
  83             return resultObj;
  84         }
  85
  86         String csarid = paramsMap.get("csarid");
  87         String vnfmid = paramsMap.get("vnfmid");
  88         String vnfdid = "";
  89
  90         if(null == csarid || "".equals(csarid)) {
  91             resultObj.put(Constant.REASON, "csarid is null.");
  92             resultObj.put(Constant.RETCODE, Constant.REST_FAIL);
  93             return resultObj;
  94         }
  95         if(null == vnfmid || "".equals(vnfmid)) {
  96             resultObj.put(Constant.REASON, "vnfmid is null.");
  97             resultObj.put(Constant.RETCODE, Constant.REST_FAIL);
  98             return resultObj;
  99         }
 100
 101         // obtain CSAR package info
 102         JSONObject csarobj = getVnfmCsarInfo(csarid);
 103         String downloadUri = "";
 104         if(Integer.valueOf(csarobj.get(Constant.RETCODE).toString()) == Constant.HTTP_OK) {
 105             LOG.info("get CSAR info successful.", csarobj.get(Constant.RETCODE));
 106             downloadUri = csarobj.getString("downloadUri");
 107         } else {
 108             LOG.error("get CSAR info fail.", csarobj.get(Constant.RETCODE));
 109             resultObj.put(Constant.REASON, csarobj.get(Constant.REASON).toString());
 110             resultObj.put(Constant.RETCODE, Constant.REST_FAIL);
 111             return resultObj;
 112         }
 113         JSONObject csarTempObj = vnfpkg.getJSONObject("template");
 114         String csarfilepath = csarTempObj.getString("csar_file_path");
 115         String csarfilename = csarTempObj.getString("csar_file_name");
 116
 117         // download csar package and save in location.
 118         JSONObject downloadObject = downloadCsar(downloadUri, csarfilepath + csarfilename);
 119
 120         if(Integer.valueOf(downloadObject.get(Constant.RETCODE).toString()) != Constant.REST_SUCCESS) {
 121             LOG.error("download CSAR fail." + downloadObject.get(Constant.RETCODE));
 122             resultObj.put(Constant.REASON, downloadObject.get(Constant.REASON).toString());
 123             resultObj.put(Constant.RETCODE, downloadObject.get(Constant.RETCODE).toString());
 124             return resultObj;
 125         }
 126         LOG.info("download CSAR successful." + downloadObject.get(Constant.RETCODE));
 127
 128         // unzip csar package to location.
 129         JSONObject unzipObject = unzipCSAR(csarfilepath + csarfilename, csarfilepath);
 130
 131         if(Integer.valueOf(unzipObject.get(Constant.RETCODE).toString()) != Constant.REST_SUCCESS) {
 132             LOG.error("unzip CSAR fail.", unzipObject.get(Constant.RETCODE));
 133             resultObj.put(Constant.REASON, unzipObject.get(Constant.REASON).toString());
 134             resultObj.put(Constant.RETCODE, unzipObject.get(Constant.RETCODE).toString());
 135             return resultObj;
 136         }
 137         LOG.info("unzip CSAR successful.", unzipObject.get(Constant.RETCODE));
 138
 139         // upload vnfd to ftps server
 140         JSONObject uploadResJson = uploadCsar(csarTempObj, csarfilepath);
 141         LOG.info("upload Csar result: {}.", uploadResJson);
 142
 143         Map<String, String> vnfmMap = new HashMap<>();
 144         vnfmMap.put("url", String.format(UrlConstant.REST_VNFMINFO_GET, vnfmid));
 145         vnfmMap.put("methodType", Constant.GET);
 146
 147         // get VNFM connection info
 148         JSONObject vnfmObject = getVnfmConnInfo(vnfmMap);
 149         if(Integer.valueOf(vnfmObject.get(Constant.RETCODE).toString()) != Constant.HTTP_OK) {
 150             LOG.error("get Vnfm Connection Info fail.", vnfmObject.get(Constant.RETCODE));
 151             resultObj.put(Constant.REASON, vnfmObject.get(Constant.REASON).toString());
 152             resultObj.put(Constant.RETCODE, vnfmObject.get(Constant.RETCODE).toString());
 153             return resultObj;
 154         }
 155         LOG.info("get Vnfm Connection Info successful.", vnfmObject.get(Constant.RETCODE));
 156
 157         String vnfmUrl = vnfmObject.getString("url");
 158         String userName = vnfmObject.getString(Constant.USERNAME);
 159         String password = vnfmObject.getString(Constant.PASSWORD);
 160
 161         // build VNFM connection and get token
 162         ConnectMgrVnfm mgrVcmm = new ConnectMgrVnfm();
 163
 164         JSONObject connObject = new JSONObject();
 165         connObject.put("url", vnfmUrl);
 166         connObject.put(Constant.USERNAME, userName);
 167         connObject.put(Constant.PASSWORD, password);
 168         if(Constant.HTTP_OK != mgrVcmm.connect(vnfmObject, Constant.CERTIFICATE)) {
 169             LOG.error("get Access Session fail.");
 170             resultObj.put(Constant.RETCODE, Constant.HTTP_INNERERROR);
 171             resultObj.put(Constant.REASON, "connect fail.");
 172             return resultObj;
 173         }
 174         LOG.info("get Access Session successful.");
 175         String connToken = mgrVcmm.getAccessSession();
 176
 177         // get vim_id
 178         JSONObject cloudObject = getAllCloud(vnfmUrl, connToken);
 179         String vimId = "";
 180
 181         if(!cloudObject.isEmpty() && cloudObject.get(Constant.RETCODE).equals(HttpStatus.SC_OK)) {
 182             LOG.info("get all cloud successful.", cloudObject.get(Constant.RETCODE));
 183             vimId = cloudObject.getString("vim_id");
 184         } else {
 185             LOG.error("get all cloud fail.", cloudObject.get(Constant.RETCODE));
 186             return cloudObject;
 187         }
 188
 189         // upload VNF package
 190         csarTempObj.put("vim_id", vimId);
 191         vnfpkg.put("template", csarTempObj);
 192         LOG.info("vnfpkg: " + vnfpkg);
 193
 194         JSONObject uploadPkgObject = upload(vnfpkg, vnfmUrl, connToken);
 195         LOG.info("uploadPkgObject:" + uploadPkgObject);
 196         if(!uploadPkgObject.isEmpty() && uploadPkgObject.get(Constant.RETCODE).equals(HttpStatus.SC_OK)) {
 197             LOG.info("upload vnf package info successful.", uploadPkgObject.get(Constant.RETCODE));
 198             vnfdid = uploadPkgObject.getString("id");
 199         }
 200
 201         if(vnfdid == null || "".equals(vnfdid.trim())) {
 202             JSONObject vnfdConf = readVnfdIdInfoFromJson();
 203             LOG.info("vnfdConf=" + vnfdConf);
 204             if(vnfdConf.containsKey(vnfDescriptorId)) {
 205                 vnfdid = vnfdConf.getString(vnfDescriptorId);
 206             }
 207         }
 208         LOG.info("set vnfdId=" + vnfdid);
 209
 210         // get vnfd version
 211         String vnfdVersion = "";
 212
 213         JSONObject vnfdVerObject =
 214                 getVnfdVersion(vnfmUrl, String.format(UrlConstant.URL_VNFDINFO_GET, vnfdid), connToken);
 215         LOG.info("vnfdVerObject:" + vnfdVerObject);
 216         if(!vnfdVerObject.isEmpty() && vnfdVerObject.get(Constant.RETCODE).equals(HttpStatus.SC_OK)) {
 217             LOG.info("get vnfd version successful.", vnfdVerObject.get(Constant.RETCODE));
 218             JSONArray verArr = vnfdVerObject.getJSONArray("templates");
 219             JSONObject verTmpObj = verArr.getJSONObject(0);
 220
 221             vnfdVersion = verTmpObj.getString("vnfdVersion");
 222         } else {
 223             LOG.error("get vnfd version fail.", vnfdVerObject.get(Constant.RETCODE));
 224             return vnfdVerObject;
 225         }
 226
 227         // get vnfd plan info
 228         String planName = "";
 229         String planId = "";
 230
 231         JSONObject vnfdPlanInfo = getVNFDPlanInfo(vnfmUrl, vnfdid, connToken);
 232         LOG.info("vnfdPlanInfo:" + vnfdPlanInfo);
 233         JSONObject inputsObj = new JSONObject();
 234         if(!vnfdPlanInfo.isEmpty() && vnfdPlanInfo.get(Constant.RETCODE).equals(HttpStatus.SC_OK)) {
 235             LOG.info("get vnfd plan info successful.", vnfdPlanInfo.get(Constant.RETCODE));
 236             JSONObject planTmpObj = vnfdPlanInfo.getJSONObject("template");
 237             String templateName = planTmpObj.getString("template_name").trim();
 238             JSONArray topoTmpObj = planTmpObj.getJSONArray("topology_template");
 239
 240             JSONObject planObj = topoTmpObj.getJSONObject(0);
 241             if("VNFD_vUGW".equals(templateName)) {
 242                 for(int i = 0; i < topoTmpObj.size(); i++) {
 243                     String name = topoTmpObj.getJSONObject(i).getString("plan_name").trim();
 244                     if("Normal_E9K".equals(name)) {
 245                         planObj = topoTmpObj.getJSONObject(i);
 246                     }
 247                 }
 248             }
 249
 250             planName = planObj.getString("plan_name");
 251             planId = planObj.getString("plan_id");
 252             if(planObj.containsKey("inputs")) {
 253                 JSONArray inputs = planObj.getJSONArray("inputs");
 254                 for(int i = 0; i < inputs.size(); i++) {
 255                     JSONObject obj = inputs.getJSONObject(i);
 256                     obj.put("value", obj.getString("default"));
 257                 }
 258                 inputsObj.put("inputs", inputs);
 259                 inputsObj.put("External_network", new JSONArray());
 260             }
 261         } else {
 262             LOG.error("get vnfd plan info fail.", vnfdPlanInfo.get(Constant.RETCODE));
 263             return vnfdPlanInfo;
 264         }
 265
 266         // return values
 267         resultObj.put(Constant.RETCODE, Constant.HTTP_OK);
 268         resultObj.put("vnfdId", vnfdid);
 269         resultObj.put("vnfdVersion", vnfdVersion);
 270         resultObj.put("planName", planName);
 271         resultObj.put("planId", planId);
 272         resultObj.put("parameters", inputsObj);
 273         LOG.info("resultObj:" + resultObj.toString());
 274
 275         return resultObj;
 276     }
 277
 278     private JSONObject uploadCsar(JSONObject vnfpkg, String csarfilepath) {
 279         LOG.info("vnfpkg: " + vnfpkg + "csarfilepath:" + csarfilepath);
 280         JSONObject resJson = new JSONObject();
 281
 282         boolean flag = false;
 283         FTPSClient ftpClient = new FTPSClient();
 284         try {
 285             ftpClient.connect(vnfpkg.getString("ftp_server_ip"), 21);
 286             ftpClient.login(vnfpkg.getString("ftp_username"), vnfpkg.getString("ftp_password"));
 287             int replyCode = ftpClient.getReplyCode();
 288             LOG.info("replyCode: " + replyCode);
 289             if(!FTPReply.isPositiveCompletion(replyCode)) {
 290                 resJson.put("message", "Connect ftps server failed!");
 291                 return resJson;
 292             }
 293
 294             ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
 295             ftpClient.enterLocalPassiveMode();
 296             ftpClient.makeDirectory(vnfpkg.getString(VNFD_FILE_PATH));
 297             LOG.info("makeDirectory: " + ftpClient.makeDirectory(vnfpkg.getString(VNFD_FILE_PATH)));
 298             ftpClient.changeWorkingDirectory(vnfpkg.getString(VNFD_FILE_PATH));
 299             LOG.info("changeWorkingDirectory: " + ftpClient.changeWorkingDirectory(vnfpkg.getString(VNFD_FILE_PATH)));
 300             String vnfdPath = csarfilepath + "Artifacts/Other/";
 301             LOG.info("vnfd_file_name: " + vnfdPath + vnfpkg.getString("vnfd_file_name"));
 302             InputStream inputStream = new FileInputStream(new File(vnfdPath + vnfpkg.getString("vnfd_file_name")));
 303             flag = ftpClient.storeFile(vnfpkg.getString("vnfd_file_name"), inputStream);
 304             if(flag) {
 305                 resJson.put("message", "upload Csar success!");
 306             }
 307             inputStream.close();
 308             ftpClient.logout();
 309         } catch(Exception e) {
 310             LOG.error("Exception: " + e);
 311         } finally {
 312             if(ftpClient.isConnected()) {
 313                 try {
 314                     ftpClient.disconnect();
 315                 } catch(IOException e) {
 316                     LOG.error("IOException: " + e);
 317                 }
 318             }
 319         }
 320         return resJson;
 321     }
 322
 323     private JSONObject sendRequest(Map<String, String> paramsMap) {
 324         JSONObject resultObj = new JSONObject();
 325         RestfulResponse rsp = VNFRestfulUtil.getRemoteResponse(paramsMap, "");
 326         if(null == rsp) {
 327             LOG.error("function=sendRequest,  RestfulResponse is null");
 328             resultObj.put(Constant.REASON, "RestfulResponse is null.");
 329             resultObj.put(Constant.RETCODE, Constant.REST_FAIL);
 330             return resultObj;
 331         }
 332         String resultCreate = rsp.getResponseContent();
 333
 334         if(rsp.getStatus() == Constant.HTTP_OK) {
 335             LOG.warn("function=sendRequest, msg= status={}, result={}.", rsp.getStatus(), resultCreate);
 336             resultObj = JSONObject.fromObject(resultCreate);
 337             resultObj.put(Constant.RETCODE, Constant.HTTP_OK);
 338             return resultObj;
 339         } else {
 340             LOG.error("function=sendRequest, msg=ESR return fail,status={}, result={}.", rsp.getStatus(), resultCreate);
 341             resultObj.put(Constant.REASON, "ESR return fail.");
 342         }
 343         resultObj.put(Constant.RETCODE, Constant.REST_FAIL);
 344         return resultObj;
 345     }
 346
 347     @Override
 348     public JSONObject getVnfmCsarInfo(String csarid) {
 349         JSONObject resultObj = new JSONObject();
 350
 351         if(null == csarid || "".equals(csarid)) {
 352             resultObj.put(Constant.REASON, "csarid is null.");
 353             resultObj.put(Constant.RETCODE, Constant.REST_FAIL);
 354             return resultObj;
 355         }
 356
 357         Map<String, String> paramsMap = new HashMap<String, String>();
 358
 359         paramsMap.put("url", String.format(UrlConstant.REST_CSARINFO_GET, csarid));
 360         paramsMap.put("methodType", Constant.GET);
 361
 362         return this.sendRequest(paramsMap);
 363     }
 364
 365     @Override
 366     public JSONObject downloadCsar(String url, String filePath) {
 367         JSONObject resultObj = new JSONObject();
 368
 369         if(url == null || "".equals(url)) {
 370             resultObj.put(Constant.REASON, "url is null.");
 371             resultObj.put(Constant.RETCODE, Constant.REST_FAIL);
 372             return resultObj;
 373         }
 374         if(filePath == null || "".equals(filePath)) {
 375             resultObj.put(Constant.REASON, "downloadUrl filePath is null.");
 376             resultObj.put(Constant.RETCODE, Constant.REST_FAIL);
 377             return resultObj;
 378         }
 379
 380         String status = DownloadCsarManager.download(url, filePath);
 381
 382         if(Constant.DOWNLOADCSAR_SUCCESS.equals(status)) {
 383             resultObj.put(Constant.REASON, "download csar file successfully.");
 384             resultObj.put(Constant.RETCODE, Constant.REST_SUCCESS);
 385         } else {
 386             resultObj.put(Constant.REASON, "download csar file failed.");
 387             resultObj.put(Constant.RETCODE, Constant.REST_FAIL);
 388         }
 389         return resultObj;
 390     }
 391
 392     @Override
 393     public JSONObject getAllCloud(String url, String conntoken) {
 394         JSONObject resultObj = new JSONObject();
 395         JSONArray resArray = new JSONArray();
 396
 397         if(url == null || url.equals("")) {
 398             url = "http://127.0.0.1:31943";
 399         }
 400
 401         // get vim_id
 402         HttpMethod httpMethodCloud = null;
 403         try {
 404             httpMethodCloud =
 405                     new HttpRequests.Builder(Constant.CERTIFICATE).setUrl(url.trim(), UrlConstant.URL_ALLCLOUD_NEW_GET)
 406                             .addHeader(Constant.HEADER_AUTH_TOKEN, conntoken).setParams("").get().execute();
 407
 408             int statusCode = httpMethodCloud.getStatusCode();
 409
 410             String result = httpMethodCloud.getResponseBodyAsString();
 411             LOG.info(result);
 412             if(statusCode == HttpStatus.SC_OK) {
 413                 JSONObject vimInfo = JSONObject.fromObject(result);
 414                 resArray = vimInfo.getJSONArray("vim_info");
 415                 resultObj = resArray.getJSONObject(0);
 416                 resultObj.put(Constant.RETCODE, statusCode);
 417             } else {
 418                 LOG.error("uploadVNFPackage get allcloud failed, code:" + statusCode + " re:" + result);
 419                 resultObj.put(Constant.RETCODE, statusCode);
 420                 resultObj.put(Constant.REASON, "get allcloud failed. code:" + statusCode + " re:" + result);
 421                 return resultObj;
 422             }
 423         } catch(JSONException e) {
 424             LOG.error("function=uploadVNFPackage, msg=uploadVNFPackage get allcloud JSONException e={}.", e);
 425             resultObj.put(Constant.RETCODE, Constant.HTTP_INNERERROR);
 426             resultObj.put(Constant.REASON, "get allcloud failed and JSONException." + e.getMessage());
 427             return resultObj;
 428         } catch(VnfmException e) {
 429             LOG.error("function=uploadVNFPackage, msg=uploadVNFPackage get allcloud VnfmException e={}.", e);
 430             resultObj.put(Constant.RETCODE, Constant.HTTP_INNERERROR);
 431             resultObj.put(Constant.REASON, "get allcloud failed and VnfmException." + e.getMessage());
 432             return resultObj;
 433         } catch(IOException e) {
 434             LOG.error("function=uploadVNFPackage, msg=uploadVNFPackage get allcloud IOException e={}.", e);
 435             resultObj.put(Constant.RETCODE, Constant.HTTP_INNERERROR);
 436             resultObj.put(Constant.REASON, "get allcloud failed and IOException." + e.getMessage());
 437             return resultObj;
 438         }
 439         return resultObj;
 440     }
 441
 442     /**
 443      * Upload vnfpackage<br>
 444      *
 445      * @param vnfpackage
 446      * @param vnfmurl
 447      * @param conntoken
 448      * @return
 449      * @since VFC 1.0
 450      */
 451     public JSONObject upload(JSONObject vnfpackage, String vnfmurl, String conntoken) {
 452         JSONObject resultObj = new JSONObject();
 453         HttpMethod httpMethodVnf = null;
 454
 455         try {
 456             httpMethodVnf = new HttpRequests.Builder(Constant.CERTIFICATE)
 457                     .setUrl(vnfmurl.trim(), UrlConstant.URL_VNFPACKAGE_POST).setParams(vnfpackage.toString())
 458                     .addHeader(Constant.HEADER_AUTH_TOKEN, conntoken).post().execute();
 459
 460             int statusCodeUp = httpMethodVnf.getStatusCode();
 461
 462             String resultUp = httpMethodVnf.getResponseBodyAsString();
 463
 464             if(statusCodeUp == HttpStatus.SC_CREATED || statusCodeUp == HttpStatus.SC_OK) {
 465                 LOG.info("uploadVNFPackage upload VNF package successful, code:" + statusCodeUp + " re:" + resultUp);
 466                 resultObj = JSONObject.fromObject(resultUp);
 467                 resultObj.put(Constant.RETCODE, statusCodeUp);
 468             } else {
 469                 LOG.error("uploadVNFPackage upload VNF package failed, code:" + statusCodeUp + " re:" + resultUp);
 470                 resultObj.put(Constant.RETCODE, statusCodeUp);
 471                 resultObj.put("data", "upload VNF package failed, code:" + statusCodeUp + " re:" + resultUp);
 472                 return resultObj;
 473             }
 474         } catch(JSONException e) {
 475             LOG.error("function=uploadVNFPackage, msg=uploadVNFPackage upload VNF package JSONException e={}.", e);
 476             resultObj.put(Constant.RETCODE, Constant.HTTP_INNERERROR);
 477             resultObj.put(Constant.REASON, "upload VNF package failed and JSONException." + e.getMessage());
 478             return resultObj;
 479         } catch(VnfmException e) {
 480             LOG.error("function=uploadVNFPackage, msg=uploadVNFPackage upload VNF package VnfmException e={}.", e);
 481             resultObj.put(Constant.RETCODE, Constant.HTTP_INNERERROR);
 482             resultObj.put(Constant.REASON, "upload VNF package failed and VnfmException." + e.getMessage());
 483             return resultObj;
 484         } catch(IOException e) {
 485             LOG.error("function=uploadVNFPackage, msg=uploadVNFPackage upload VNF package IOException e={}.", e);
 486             resultObj.put(Constant.RETCODE, Constant.HTTP_INNERERROR);
 487             resultObj.put(Constant.REASON, "upload VNF package failed and IOException." + e.getMessage());
 488             return resultObj;
 489         }
 490         return resultObj;
 491     }
 492
 493     /**
 494      * Find vnfd version.<br>
 495      *
 496      * @param prefixUrl
 497      * @param serviceUrl
 498      * @return
 499      * @since VFC 1.0
 500      */
 501     public JSONObject getVnfdVersion(String prefixUrl, String serviceUrl, String conntoken) {
 502         JSONObject resultObj = new JSONObject();
 503         HttpMethod httpMethodVnfd = null;
 504         try {
 505             httpMethodVnfd = new HttpRequests.Builder(Constant.CERTIFICATE).setUrl(prefixUrl.trim(), serviceUrl)
 506                     .setParams("").addHeader(Constant.HEADER_AUTH_TOKEN, conntoken).get().execute();
 507
 508             int statusCodeVnfd = httpMethodVnfd.getStatusCode();
 509
 510             String resultVnfd = httpMethodVnfd.getResponseBodyAsString();
 511             LOG.info("getVnfdVersion result:" + resultVnfd);
 512             if(statusCodeVnfd == HttpStatus.SC_OK) {
 513                 resultObj = JSONObject.fromObject(resultVnfd);
 514                 resultObj.put(Constant.RETCODE, statusCodeVnfd);
 515             } else {
 516                 LOG.error("uploadVNFPackage vnfd version failed, code:" + statusCodeVnfd + " re:" + resultVnfd);
 517                 resultObj.put(Constant.RETCODE, statusCodeVnfd);
 518                 resultObj.put("data", "get vnfd version failed, code:" + statusCodeVnfd + " re:" + resultVnfd);
 519                 return resultObj;
 520             }
 521         } catch(JSONException e) {
 522             LOG.error("function=uploadVNFPackage, msg=uploadVNFPackage get vnfd version JSONException e={}.", e);
 523             resultObj.put(Constant.RETCODE, Constant.HTTP_INNERERROR);
 524             resultObj.put(Constant.REASON, "get vnfd version failed and JSONException." + e.getMessage());
 525             return resultObj;
 526         } catch(VnfmException e) {
 527             LOG.error("function=uploadVNFPackage, msg=uploadVNFPackage get vnfd version VnfmException e={}.", e);
 528             resultObj.put(Constant.RETCODE, Constant.HTTP_INNERERROR);
 529             resultObj.put(Constant.REASON, "get vnfd version failed and VnfmException." + e.getMessage());
 530             return resultObj;
 531         } catch(IOException e) {
 532             LOG.error("function=uploadVNFPackage, msg=uploadVNFPackage get vnfd version IOException e={}.", e);
 533             resultObj.put(Constant.RETCODE, Constant.HTTP_INNERERROR);
 534             resultObj.put(Constant.REASON, "get vnfd version failed and IOException." + e.getMessage());
 535             return resultObj;
 536         }
 537         return resultObj;
 538     }
 539
 540     /**
 541      * Find VNFM connection information.<br>
 542      *
 543      * @param paramsMap
 544      * @return
 545      * @since VFC 1.0
 546      */
 547     public JSONObject getVnfmConnInfo(Map<String, String> paramsMap) {
 548         return this.sendRequest(paramsMap);
 549     }
 550
 551     @Override
 552     public JSONObject getVNFDPlanInfo(String url, String vnfdid, String conntoken) {
 553         JSONObject resultObj = new JSONObject();
 554
 555         HttpMethod httpMethodPlan = null;
 556         try {
 557             httpMethodPlan = new HttpRequests.Builder(Constant.CERTIFICATE)
 558                     .setUrl(url.trim(), String.format(UrlConstant.URL_VNFDPLANINFO_GET, vnfdid)).setParams("")
 559                     .addHeader(Constant.HEADER_AUTH_TOKEN, conntoken).get().execute();
 560
 561             int statusCode = httpMethodPlan.getStatusCode();
 562
 563             String result = httpMethodPlan.getResponseBodyAsString();
 564             LOG.info("getVNFDPlanInfo result=" + result);
 565             if(statusCode == HttpStatus.SC_OK) {
 566                 resultObj = JSONObject.fromObject(result);
 567                 resultObj.put(Constant.RETCODE, statusCode);
 568             } else {
 569                 LOG.error("uploadVNFPackage get VNFDPlanInfo failed, code:" + statusCode + " re:" + result);
 570                 resultObj.put(Constant.RETCODE, statusCode);
 571                 resultObj.put(Constant.REASON, "get VNFDPlanInfo failed. code:" + statusCode + " re:" + result);
 572                 return resultObj;
 573             }
 574         } catch(JSONException e) {
 575             LOG.error("function=uploadVNFPackage, msg=uploadVNFPackage get VNFDPlanInfo JSONException e={}.", e);
 576             resultObj.put(Constant.RETCODE, Constant.HTTP_INNERERROR);
 577             resultObj.put(Constant.REASON, "get VNFDPlanInfo failed and JSONException." + e.getMessage());
 578             return resultObj;
 579         } catch(VnfmException e) {
 580             LOG.error("function=uploadVNFPackage, msg=uploadVNFPackage get VNFDPlanInfo VnfmException e={}.", e);
 581             resultObj.put(Constant.RETCODE, Constant.HTTP_INNERERROR);
 582             resultObj.put(Constant.REASON, "get VNFDPlanInfo failed and VnfmException." + e.getMessage());
 583             return resultObj;
 584         } catch(IOException e) {
 585             LOG.error("function=uploadVNFPackage, msg=uploadVNFPackage get VNFDPlanInfo IOException e={}.", e);
 586             resultObj.put(Constant.RETCODE, Constant.HTTP_INNERERROR);
 587             resultObj.put(Constant.REASON, "get VNFDPlanInfo failed and IOException." + e.getMessage());
 588             return resultObj;
 589         }
 590         return resultObj;
 591     }
 592
 593     /**
 594      * Get VNF package information.<br>
 595      *
 596      * @return
 597      * @throws IOException
 598      * @since VFC 1.0
 599      */
 600     public static String readVfnPkgInfoFromJson() throws IOException {
 601         InputStream ins = null;
 602         BufferedInputStream bins = null;
 603         String fileContent = "";
 604
 605         String fileName = SystemEnvVariablesFactory.getInstance().getAppRoot()
 606                 + System.getProperty(Constant.FILE_SEPARATOR) + "etc" + System.getProperty(Constant.FILE_SEPARATOR)
 607                 + "vnfpkginfo" + System.getProperty(Constant.FILE_SEPARATOR) + Constant.VNFPKGINFO;
 608
 609         try {
 610             ins = new FileInputStream(fileName);
 611             bins = new BufferedInputStream(ins);
 612
 613             byte[] contentByte = new byte[ins.available()];
 614             int num = bins.read(contentByte);
 615
 616             if(num > 0) {
 617                 fileContent = new String(contentByte);
 618             }
 619         } catch(FileNotFoundException e) {
 620             LOG.error(fileName + "is not found!", e);
 621         } finally {
 622             if(ins != null) {
 623                 ins.close();
 624             }
 625             if(bins != null) {
 626                 bins.close();
 627             }
 628         }
 629
 630         return fileContent;
 631     }
 632
 633     private static JSONObject readVnfdIdInfoFromJson() {
 634         JSONObject jsonObject = new JSONObject();
 635         InputStream ins = null;
 636         BufferedInputStream bins = null;
 637         String fileContent = "";
 638
 639         String fileName = SystemEnvVariablesFactory.getInstance().getAppRoot()
 640                 + System.getProperty(Constant.FILE_SEPARATOR) + "etc" + System.getProperty(Constant.FILE_SEPARATOR)
 641                 + "vnfpkginfo" + System.getProperty(Constant.FILE_SEPARATOR) + "vnfd_ids.json";
 642
 643         try {
 644             ins = new FileInputStream(fileName);
 645             bins = new BufferedInputStream(ins);
 646
 647             byte[] contentByte = new byte[ins.available()];
 648             int num = bins.read(contentByte);
 649
 650             if(num > 0) {
 651                 fileContent = new String(contentByte);
 652             }
 653             if(fileContent != null) {
 654                 jsonObject = JSONObject.fromObject(fileContent).getJSONObject("vnfdIds");
 655             }
 656             ins.close();
 657             bins.close();
 658         } catch(Exception e) {
 659             LOG.error(fileName + " read error!", e);
 660         } finally {
 661
 662         }
 663
 664         return jsonObject;
 665     }
 666
 667     /*
 668      * unzip CSAR packge
 669      * @param fileName filePath
 670      * @return
 671      */
 672     public JSONObject unzipCSAR(String fileName, String filePath) {
 673         LOG.info("fileName: " + fileName + ", filePath: " + filePath);
 674         JSONObject resultObj = new JSONObject();
 675
 676         if(fileName == null || "".equals(fileName)) {
 677             resultObj.put(Constant.REASON, "fileName is null.");
 678             resultObj.put(Constant.RETCODE, Constant.REST_FAIL);
 679             return resultObj;
 680         }
 681         if(filePath == null || "".equals(filePath)) {
 682             resultObj.put(Constant.REASON, "unzipCSAR filePath is null.");
 683             resultObj.put(Constant.RETCODE, Constant.REST_FAIL);
 684             return resultObj;
 685         }
 686
 687         int status = DownloadCsarManager.unzipCSAR(fileName, filePath);
 688
 689         if(Constant.UNZIP_SUCCESS == status) {
 690             resultObj.put(Constant.REASON, "unzip csar file successfully.");
 691             resultObj.put(Constant.RETCODE, Constant.REST_SUCCESS);
 692         } else {
 693             resultObj.put(Constant.REASON, "unzip csar file failed.");
 694             resultObj.put(Constant.RETCODE, Constant.REST_FAIL);
 695         }
 696         return resultObj;
 697     }
 698
 699 }