rest-client/src/main/java/org/openo/baseservice/roa/util/restclient/RestfulConfigure.java

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