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 }