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