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

   1 /*
   2  * Copyright 2016 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.gvnfm.jujuvnfmadapter.common.restclient;
  18
  19 import java.io.BufferedReader;
  20 import java.io.File;
  21 import java.io.FileReader;
  22 import java.io.IOException;
  23
  24 import org.slf4j.Logger;
  25 import org.slf4j.LoggerFactory;
  26
  27 import net.sf.json.JSONObject;
  28
  29 /**
  30  * Rest client options.<br/>
  31  * <p>
  32  * </p>
  33  *
  34  * @author
  35  * @version 28-May-2016
  36  */
  37 public class RestfulConfigure {
  38
  39     private static final Logger LOG = LoggerFactory.getLogger(RestfulConfigure.class);
  40
  41     private RestfulOptions options = null;
  42
  43     /**
  44      * Constructor<br/>
  45      * <p>
  46      * Use the default path initialization http Rest options.
  47      * </p>
  48      *
  49      * @since
  50      */
  51     public RestfulConfigure() {
  52         final String config = "/etc/conf/restclient.json";
  53         final String approot = SystemEnvVariablesFactory.getInstance().getAppRoot();
  54         final StringBuilder extendSetting = new StringBuilder();
  55
  56         if(approot != null) {
  57             extendSetting.append(approot);
  58             extendSetting.append(config);
  59         } else {
  60             extendSetting.append(System.getProperty("user.dir"));
  61             extendSetting.append(config);
  62         }
  63
  64         final String configfile = extendSetting.toString();
  65         initRestConf(configfile);
  66     }
  67
  68     /**
  69      * Constructor<br/>
  70      * <p>
  71      * Use the specified file to initialize http Rest options.
  72      * </p>
  73      *
  74      * @since
  75      * @param configfile
  76      */
  77     public RestfulConfigure(final String configfile) {
  78         initRestConf(configfile);
  79     }
  80
  81     public RestfulOptions getOptions() {
  82         return options;
  83     }
  84
  85     private void initRestConf(final String configfile) {
  86         options = getDefaultOptions();
  87
  88         final JSONObject obj = loadJsonFromFile(configfile);
  89         if(obj != null) {
  90             if(obj.has(RestfulClientConst.SERVER_KEY_NAME)) {
  91                 final JSONObject server = obj.getJSONObject(RestfulClientConst.SERVER_KEY_NAME);
  92                 setStringOption(server, RestfulClientConst.HOST_KEY_NAME);
  93                 setIntOption(server, RestfulClientConst.PORT_KEY_NAME);
  94             }
  95             setIntOption(obj, RestfulClientConst.CONN_TIMEOUT_KEY_NAME);
  96             setIntOption(obj, RestfulClientConst.THREAD_KEY_NAME);
  97             setIntOption(obj, RestfulClientConst.IDLE_TIMEOUT_KEY_NAME);
  98             setIntOption(obj, RestfulClientConst.TIMEOUT_KEY_NAME);
  99             setIntOption(obj, RestfulClientConst.MAX_CONN_PER_ADDR_KEY_NAME);
 100             setIntOption(obj, RestfulClientConst.MAX_RESPONSE_HEADER_SIZE);
 101             setIntOption(obj, RestfulClientConst.MAX_REQUEST_HEADER_SIZE);
 102         } else {
 103             LOG.error("failed to load json from " + configfile);
 104         }
 105     }
 106
 107     private void setStringOption(final JSONObject json, final String key) {
 108         if(json.has(key)) {
 109             options.setOption(key, json.getString(key));
 110         }
 111     }
 112
 113     private void setIntOption(final JSONObject json, final String key) {
 114         if(json.has(key)) {
 115             options.setOption(key, json.getInt(key));
 116         }
 117     }
 118
 119     private RestfulOptions getDefaultOptions() {
 120         options = new RestfulOptions();
 121         options.setOption(RestfulClientConst.CONN_TIMEOUT_KEY_NAME, 3000);
 122         options.setOption(RestfulClientConst.THREAD_KEY_NAME, 200);
 123         options.setOption(RestfulClientConst.IDLE_TIMEOUT_KEY_NAME, 30000);
 124         options.setOption(RestfulClientConst.TIMEOUT_KEY_NAME, 30000);
 125         options.setOption(RestfulClientConst.MAX_CONN_PER_ADDR_KEY_NAME, 50);
 126         options.setOption(RestfulClientConst.MAX_RESPONSE_HEADER_SIZE, 20 * 1024);
 127         options.setOption(RestfulClientConst.MAX_REQUEST_HEADER_SIZE, 20 * 1024);
 128         return options;
 129     }
 130
 131     private JSONObject loadJsonFromFile(final String filePath) {
 132         final File file = new File(filePath);
 133         if((!file.exists()) || (!file.isFile())) {
 134             LOG.error(filePath + "isn't exist.");
 135             return null;
 136         }
 137         BufferedReader reader = null;
 138         final StringBuilder jsonstr = new StringBuilder();
 139         JSONObject jo = null;
 140         try {
 141             reader = new BufferedReader(new FileReader(file));
 142             final ReaderHelper rHelpper = new ReaderHelper(reader);
 143             String tempString = null;
 144             while((tempString = rHelpper.getLine()) != null) {
 145                 jsonstr.append(tempString);
 146             }
 147             jo = JSONObject.fromObject(jsonstr.toString());
 148         } catch(final IOException e) {
 149             LOG.error("load file exception:" + e);
 150         } finally {
 151             if(reader != null) {
 152                 try {
 153                     reader.close();
 154                 } catch(final IOException e) {
 155                     LOG.error("close error.", e);
 156                 }
 157             }
 158         }
 159         return jo;
 160     }
 161 }