gerrit.onap Code Review - vfc/nfvo/driver/vnfm/svnfm.git/blob

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