innov
/
aggregation-platform
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

合并，解决冲突

Browse Source
glusterfs-api
chenlw 9 years ago
parent ab64ab35d2 e2e392e319
commit 355b6e47a4
14 changed files with 2088 additions and 2075 deletions
Show Stats Download Patch File Download Diff File

456
src/com/platform/controller/DataModelController.java
Unescape View File

@ -1,228 +1,228 @@
package com.platform.controller;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.apache.commons.lang.StringUtils;
import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Service;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import com.base.BaseController;
import com.platform.entities.DataInfoEntity;
import com.platform.entities.FolderNode;
import com.platform.entities.GatherOracleInfo;
import com.platform.entities.OracleConnectorParams;
import com.platform.entities.PagerOptions;
import com.platform.entities.VolumeEntity;
import com.platform.service.DataInfoService;
import com.platform.service.IGfsService;
import com.platform.service.IMySqlService;
import com.platform.service.IOracleExtractService;
import com.platform.service.OracleExtractHelper;
import com.platform.service.OracleStatusService;
import com.platform.service.impl.MySqlServiceImpl;
import com.platform.test.Brick;
import com.platform.test.FolderReader;
import com.platform.test.Volume;
import com.platform.utils.Configs;
import com.platform.utils.UtilsHelper;
@Controller
public class DataModelController extends BaseController{
@Resource(name = "dataInfoService")
private DataInfoService dfs;
@Resource(name = "gfsService")
private IGfsService gfsService;
@Resource(name = "mySqlService")
private IMySqlService mySqlService;
@Resource(name = "OracleExtract")
private IOracleExtractService OracleExtract;
public void setDfsImp(DataInfoService dfs) {
this.dfs = dfs;
}
@RequestMapping("/data.json")
@ResponseBody
public ModelMap getAllDataToJson(HttpServletRequest res,
HttpServletResponse req) {
Map<String, String[]> paramMap = res.getParameterMap();
Set<String> keySet = paramMap.keySet();
Map<String, String> params = new HashMap<String, String>();
StringBuffer sb = new StringBuffer().append("<22><>ǰ<EFBFBD><C7B0><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:{");
for (String str : keySet) {
String value = paramMap.get(str)[0];
if (StringUtils.isNotEmpty(value)) {
params.put(str, value);
sb.append(str).append(":").append(value).append(",");
} else {
sb.append(str).append(":").append("null").append(",");
}
}
Configs.CONSOLE_LOGGER.info(sb.deleteCharAt(sb.length() - 1)
.append("}").toString());
PagerOptions pagerOptions = (PagerOptions) UtilsHelper
.newObjAndSetAttrsByClass(PagerOptions.class, params);
return dfs.getPagerTableData(pagerOptions);
}
@RequestMapping("/delete/data")
public void deleteData(HttpServletRequest res, HttpServletResponse req) {
Map<String, String[]> paramMap = res.getParameterMap();
String[] data = paramMap.get("data");
dfs.deleteData(data);
}
@RequestMapping("/connectOracle")
public void connectOracle(HttpServletRequest res, HttpServletResponse req) {
Map<String, String[]> paramMap = res.getParameterMap();
String[] oraclesName = paramMap.get("oracleName");
if (oraclesName != null)
for (String rcName : oraclesName) {
Configs.CONSOLE_LOGGER.info("连接成功\t" + rcName);
new OracleStatusService().connectToOracle(rcName);
}
}
@RequestMapping("/cancelOracleConection")
public void cancelOracleConnection(HttpServletRequest res,
HttpServletResponse req) {
Map<String, String[]> paramMap = res.getParameterMap();
String[] oraclesName = paramMap.get("oracleName");
String operate = paramMap.get("operation")[0];
if (null != oraclesName) {
for (String rcName : oraclesName) {
Configs.CONSOLE_LOGGER.info("连接成功:\t" + rcName);
new OracleStatusService().cancelToOracle(rcName, operate);
}
}
}
@RequestMapping("/oracle/{name}/extract")
public void extractOracleData(HttpServletRequest res,
HttpServletResponse req, String name) throws Exception {
System.out.println("------extract-------");
System.out.println(name);
Map<String, String[]> paramMap = res.getParameterMap();
//汇总库 对象信息--带有tableName-
String[] nodes = paramMap.get("target");
Map map = null;
for (String string : nodes) {
JSONObject jsonobject = JSONObject.fromObject(string);
map = jsonobject;
System.out.println(map);
}
// 采集库对象--(多个采集库抽取到1个汇总库的1个tableName下)
String[] inneed = paramMap.get("inneed");
List<Map<String, String>> colleclist = new ArrayList<Map<String,String>>();
for (String string : nodes) {
JSONObject jsonobject = JSONObject.fromObject(string);
Map inneedMap = jsonobject;
colleclist.add(inneedMap);
}
OracleExtract.extractOracle(name, colleclist, map);
}
@RequestMapping("/volume/list")
@ResponseBody
public List<VolumeEntity> getFolder(HttpServletRequest res, HttpServletResponse req) throws Exception {
System.out.println("get Request");
// Brick brick1 = new Brick("192.168.0.101", "D:/bootstrap");
// Brick brick2 = new Brick("192.168.0.103", "D:\book");
// List<Brick> bricks = new ArrayList<Brick>();
// bricks.add(brick1);
// bricks.add(brick2);
List<VolumeEntity> result = gfsService.getAllVolumes();
return result;
}
@RequestMapping(value = "/volume/{name}/move", method= RequestMethod.POST)
@ResponseBody
public Object move(HttpServletRequest res, HttpServletResponse req, String name,
FolderNode selectNode, DataInfoEntity selectItems) throws Exception {
System.out.println("get Request");
Map<String, String[]> paramMap = res.getParameterMap();
// System.out.println(paramMap);
String[] nodes = paramMap.get("selectNode");
Map map = null;
for (String string : nodes) {
System.out.println(string);
JSONObject jsonobject = JSONObject.fromObject(string);
map = jsonobject;
}
List<String> listItemPath = new ArrayList<String>();
String[] items = paramMap.get("selectItems");
System.out.println("selectItems");
for (String string : items) {
System.out.println(string);
JSONObject jsobj = JSONObject.fromObject(string);
Map itemmap = jsobj;
listItemPath.add((String)itemmap.get("dataPath"));
}
System.out.println(name);
System.out.println(nodes);
System.out.println(selectItems);
System.out.println("--------------");
int result = gfsService.copyFolder(listItemPath, (String)map.get("path"), "app");
return result;
}
@RequestMapping("/oracle/list")
@ResponseBody
public List<GatherOracleInfo> getOracleInfo(HttpServletRequest res,
HttpServletResponse req) throws Exception {
List<GatherOracleInfo> result = mySqlService.findAllMySql();
System.out.println("----------getOracleInfo-----------------------");
return result;
}
@RequestMapping("/oracle/{id}/delete")
@ResponseBody
public void deleteOracleInfo(HttpServletRequest res,
HttpServletResponse req, int id) throws Exception {
mySqlService.deleteMySql(id);
System.out.println("----------deleteOracleInfo-----------------------");
}
@RequestMapping("/oracle/{id}/insert")
@ResponseBody
public void insertOracleInfo(HttpServletRequest res,
HttpServletResponse req, GatherOracleInfo oracle) throws Exception {
mySqlService.insertOracle(oracle);
System.out.println("----------insertOracleInfo-----------------------");
}
@RequestMapping("/oracle/{id}/update")
@ResponseBody
public void updateOracleInfo(HttpServletRequest res,
HttpServletResponse req, GatherOracleInfo oracle) throws Exception {
mySqlService.updateOracle(oracle);
System.out.println("----------updateOracleInfo-----------------------");
}
}
package com.platform.controller;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.apache.commons.lang.StringUtils;
import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Service;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import com.base.BaseController;
import com.platform.entities.DataInfoEntity;
import com.platform.entities.FolderNode;
import com.platform.entities.GatherOracleInfo;
import com.platform.entities.OracleConnectorParams;
import com.platform.entities.PagerOptions;
import com.platform.entities.VolumeEntity;
import com.platform.service.DataInfoService;
import com.platform.service.IGfsService;
import com.platform.service.IMySqlService;
import com.platform.service.IOracleExtractService;
import com.platform.service.OracleExtractHelper;
import com.platform.service.OracleStatusService;
import com.platform.service.impl.MySqlServiceImpl;
import com.platform.test.Brick;
import com.platform.test.FolderReader;
import com.platform.test.Volume;
import com.platform.utils.Configs;
import com.platform.utils.UtilsHelper;
@Controller
public class DataModelController extends BaseController{
@Resource(name = "dataInfoService")
private DataInfoService dfs;
@Resource(name = "gfsService")
private IGfsService gfsService;
@Resource(name = "mySqlService")
private IMySqlService mySqlService;
@Resource(name = "OracleExtract")
private IOracleExtractService OracleExtract;
public void setDfsImp(DataInfoService dfs) {
this.dfs = dfs;
}
@RequestMapping("/data.json")
@ResponseBody
public ModelMap getAllDataToJson(HttpServletRequest res,
HttpServletResponse req) {
Map<String, String[]> paramMap = res.getParameterMap();
Set<String> keySet = paramMap.keySet();
Map<String, String> params = new HashMap<String, String>();
StringBuffer sb = new StringBuffer().append("<22><>ǰ<EFBFBD><C7B0><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:{");
for (String str : keySet) {
String value = paramMap.get(str)[0];
if (StringUtils.isNotEmpty(value)) {
params.put(str, value);
sb.append(str).append(":").append(value).append(",");
} else {
sb.append(str).append(":").append("null").append(",");
}
}
Configs.CONSOLE_LOGGER.info(sb.deleteCharAt(sb.length() - 1)
.append("}").toString());
PagerOptions pagerOptions = (PagerOptions) UtilsHelper
.newObjAndSetAttrsByClass(PagerOptions.class, params);
return dfs.getPagerTableData(pagerOptions);
}
@RequestMapping("/delete/data")
public void deleteData(HttpServletRequest res, HttpServletResponse req) {
Map<String, String[]> paramMap = res.getParameterMap();
String[] data = paramMap.get("data");
dfs.deleteData(data);
}
@RequestMapping("/connectOracle")
public void connectOracle(HttpServletRequest res, HttpServletResponse req) {
Map<String, String[]> paramMap = res.getParameterMap();
String[] oraclesName = paramMap.get("oracleName");
if (oraclesName != null)
for (String rcName : oraclesName) {
Configs.CONSOLE_LOGGER.info("连接成功\t" + rcName);
new OracleStatusService().connectToOracle(rcName);
}
}
@RequestMapping("/cancelOracleConection")
public void cancelOracleConnection(HttpServletRequest res,
HttpServletResponse req) {
Map<String, String[]> paramMap = res.getParameterMap();
String[] oraclesName = paramMap.get("oracleName");
String operate = paramMap.get("operation")[0];
if (null != oraclesName) {
for (String rcName : oraclesName) {
Configs.CONSOLE_LOGGER.info("连接成功:\t" + rcName);
new OracleStatusService().cancelToOracle(rcName, operate);
}
}
}
@RequestMapping("/oracle/{name}/extract")
public void extractOracleData(HttpServletRequest res,
HttpServletResponse req, String name) throws Exception {
System.out.println("------extract-------");
System.out.println(name);
Map<String, String[]> paramMap = res.getParameterMap();
//汇总库 对象信息--带有tableName-
String[] nodes = paramMap.get("target");
Map map = null;
for (String string : nodes) {
JSONObject jsonobject = JSONObject.fromObject(string);
map = jsonobject;
System.out.println(map);
}
// 采集库对象--(多个采集库抽取到1个汇总库的1个tableName下)
String[] inneed = paramMap.get("inneed");
List<Map<String, String>> colleclist = new ArrayList<Map<String,String>>();
for (String string : nodes) {
JSONObject jsonobject = JSONObject.fromObject(string);
Map inneedMap = jsonobject;
colleclist.add(inneedMap);
}
OracleExtract.extractOracle(name, colleclist, map);
}
@RequestMapping("/volume/list")
@ResponseBody
public List<VolumeEntity> getFolder(HttpServletRequest res, HttpServletResponse req) throws Exception {
System.out.println("get Request");
// Brick brick1 = new Brick("192.168.0.101", "D:/bootstrap");
// Brick brick2 = new Brick("192.168.0.103", "D:\book");
// List<Brick> bricks = new ArrayList<Brick>();
// bricks.add(brick1);
// bricks.add(brick2);
List<VolumeEntity> result = gfsService.getAllVolumes();
return result;
}
@RequestMapping(value = "/volume/{name}/move", method= RequestMethod.POST)
@ResponseBody
public Object move(HttpServletRequest res, HttpServletResponse req, String name,
FolderNode selectNode, DataInfoEntity selectItems) throws Exception {
System.out.println("get Request");
Map<String, String[]> paramMap = res.getParameterMap();
// System.out.println(paramMap);
String[] nodes = paramMap.get("selectNode");
Map map = null;
for (String string : nodes) {
System.out.println(string);
JSONObject jsonobject = JSONObject.fromObject(string);
map = jsonobject;
}
List<String> listItemPath = new ArrayList<String>();
String[] items = paramMap.get("selectItems");
System.out.println("selectItems");
for (String string : items) {
System.out.println(string);
JSONObject jsobj = JSONObject.fromObject(string);
Map itemmap = jsobj;
listItemPath.add((String)itemmap.get("dataPath"));
}
System.out.println(name);
System.out.println(nodes);
System.out.println(selectItems);
System.out.println("--------------");
int result = gfsService.copyFolder(listItemPath, (String)map.get("path"), "app");
return result;
}
@RequestMapping("/oracle/list")
@ResponseBody
public List<GatherOracleInfo> getOracleInfo(HttpServletRequest res,
HttpServletResponse req) throws Exception {
List<GatherOracleInfo> result = mySqlService.findAllMySql();
System.out.println("----------getOracleInfo-----------------------");
return result;
}
@RequestMapping("/oracle/{id}/delete")
@ResponseBody
public void deleteOracleInfo(HttpServletRequest res,
HttpServletResponse req, int id) throws Exception {
mySqlService.deleteMySql(id);
System.out.println("----------deleteOracleInfo-----------------------");
}
@RequestMapping("/oracle/{id}/insert")
@ResponseBody
public void insertOracleInfo(HttpServletRequest res,
HttpServletResponse req, GatherOracleInfo oracle) throws Exception {
mySqlService.insertOracle(oracle);
System.out.println("----------insertOracleInfo-----------------------");
}
@RequestMapping("/oracle/{id}/update")
@ResponseBody
public void updateOracleInfo(HttpServletRequest res,
HttpServletResponse req, GatherOracleInfo oracle) throws Exception {
mySqlService.updateOracle(oracle);
System.out.println("----------updateOracleInfo-----------------------");
}
}

184
src/com/platform/entities/Brick.java
Unescape View File

@ -1,91 +1,93 @@
/**
* 文件名 : Brick.java
* 版权 : <版权/公司名>
* 描述 : <描述>
* @author chen
* 版本 : <版本>
* 修改时间： 2016年9月9日
* 修改内容： <修改内容>
*/
package com.platform.entities;
/**
* <一句话功能简述> volume 下的 块 对象
* <功能详细描述>
* @author chen
* @version [版本号，2016年9月9日]
* @see [相关类/方法]
* @since [产品/模块版本]
*/
public class Brick {
/** volume总大小 */
private double availableSize;
/** volume已使用大小 */
private double usedSize;
/** ip */
private String ip;
/** 路径 */
private String path;
/**
* @return the availableSize
*/
public double getAvailableSize() {
return availableSize;
}
/**
* @param availableSize the availableSize to set
*/
public void setAvailableSize(double availableSize) {
this.availableSize = availableSize;
}
/**
* @return the usedSize
*/
public double getUsedSize() {
return usedSize;
}
/**
* @param usedSize the usedSize to set
*/
public void setUsedSize(double usedSize) {
this.usedSize = usedSize;
}
/**
* @return the ip
*/
public String getIp() {
return ip;
}
/**
* @param ip the ip to set
*/
public void setIp(String ip) {
this.ip = ip;
}
/**
* @return the path
*/
public String getPath() {
return path;
}
/**
* @param path the path to set
*/
public void setPath(String path) {
this.path = path;
}
}
/**
* 文件名 : Brick.java
* 版权 : <版权/公司名>
* 描述 : <描述>
* @author chen
* 版本 : <版本>
* 修改时间： 2016年9月9日
* 修改内容： <修改内容>
*/
package com.platform.entities;
/**
* <一句话功能简述> volume 下的 块 对象
* <功能详细描述>
* @author chen
* @version [版本号，2016年9月9日]
* @see [相关类/方法]
* @since [产品/模块版本]
*/
public class Brick {
/** volume总大小 */
private double availableSize;
/** volume已使用大小 */
private double usedSize;
/** ip */
private String ip;
/** 路径 */
private String path;
/**
* @return the availableSize
*/
public double getAvailableSize() {
return availableSize;
}
/**
* @param availableSize the availableSize to set
*/
public void setAvailableSize(double availableSize) {
this.availableSize = availableSize;
}
/**
* @return the usedSize
*/
public double getUsedSize() {
return usedSize;
}
/**
* @param usedSize the usedSize to set
*/
public void setUsedSize(double usedSize) {
this.usedSize = usedSize;
}
/**
* @return the ip
*/
public String getIp() {
return ip;
}
/**
* @param ip the ip to set
*/
public void setIp(String ip) {
this.ip = ip;
}
/**
* @return the path
*/
public String getPath() {
return path;
}
/**
* @param path the path to set
*/
public void setPath(String path) {
this.path = path;
}
}

220
src/com/platform/glusterfs/ClusterInfo.java
Unescape View File

@ -1,110 +1,110 @@
package com.platform.glusterfs;
import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import com.platform.utils.Constant;
/**
* 获取集群节点信息
* 如果获取不正常，则返回null，如果获取正常，返回map表示节点ip和ip的状态
* 如果ip在集群中且联通状态为PeerinCluster(Connected)
* 如果ip在集群中且但不连通为PeerinCluster(Disconnected)
* @author liliy
* @version [版本号，2016年9月12日]
* @see [相关类/方法]
* @since [产品/模块版本]
*/
public class ClusterInfo {
public static Logger log = Logger.getLogger(ClusterInfo.class);
public Map<String, String> showClusterInfo() {
log.info("get cluster info");
Map<String, String> peerIps = new HashMap<String, String>();
List<String> reStrings = Constant.ganymedSSH.execCmdWait(Constant.hostIp, Constant.rootUser, Constant.rootPasswd, Constant.port, Constant.glusterPeerStatus);
if (reStrings == null) {
log.error("1101 command get result is null");
return null;
}
if (reStrings.size() == 0) {
log.error("1102 command get result is nothing");
return null;
}
if (!(reStrings.get(0).split(":")[0].contains("Number of Peers"))) {
log.error("1103 get result string wrong");
return null;
}
// System.out.print(reStrings.get(0));
int flag = 0;
String ipString = "";
String state = "";
for (Iterator it2 = reStrings.iterator(); it2.hasNext();) {
String line = (String) it2.next();
line=line.replaceAll(" +", " ");
String keyValue[] = line.split(":");
if (keyValue[0].equals("Hostname")) {
if (keyValue.length < 2) {
log.error("1105 command get result is wrong");
continue;
}
ipString = keyValue[1].replaceAll(" ", "");
flag = 1;
} else if (flag == 1 && keyValue[0].equals("State")) {
if (keyValue.length < 2) {
log.error("1106 command get result is wrong");
continue;
}
state = keyValue[1].replaceAll(" ", "");
flag = 0;
peerIps.put(ipString, state);
}
}
return peerIps;
}
/**
* 根据给定的ip获的ip的状态，即是否在集群中并联通
* 如果ip不在集群中，返回null
* 如果ip在集群中且联通状态为PeerinCluster(Connected)
* 如果ip在集群中且但不连通为PeerinCluster(Disconnected)
* @param peerip
* @return
* @see [类、类#方法、类#成员]
*/
public String getPeerStatus(String peerip){
Map<String, String> peerIps=showClusterInfo();
if(peerIps==null || peerIps.size()==0){
return null;
}
if(!peerIps.containsKey(peerip)){
return Constant.peerincluster_disconnected;
}
return peerIps.get(peerip);
}
public static void main(String[] args) {
PropertyConfigurator.configure("log4j.properties");
System.out.println(new ClusterInfo().showClusterInfo());
}
}
package com.platform.glusterfs;
import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import com.platform.utils.Constant;
/**
* 获取集群节点信息
* 如果获取不正常，则返回null，如果获取正常，返回map表示节点ip和ip的状态
* 如果ip在集群中且联通状态为PeerinCluster(Connected)
* 如果ip在集群中且但不连通为PeerinCluster(Disconnected)
* @author liliy
* @version [版本号，2016年9月12日]
* @see [相关类/方法]
* @since [产品/模块版本]
*/
public class ClusterInfo {
public static Logger log = Logger.getLogger(ClusterInfo.class);
public Map<String, String> showClusterInfo() {
log.info("get cluster info");
Map<String, String> peerIps = new HashMap<String, String>();
List<String> reStrings = Constant.ganymedSSH.execCmdWait(Constant.hostIp, Constant.rootUser, Constant.rootPasswd, Constant.port, Constant.glusterPeerStatus);
if (reStrings == null) {
log.error("1101 command get result is null");
return null;
}
if (reStrings.size() == 0) {
log.error("1102 command get result is nothing");
return null;
}
if (!(reStrings.get(0).split(":")[0].contains("Number of Peers"))) {
log.error("1103 get result string wrong");
return null;
}
// System.out.print(reStrings.get(0));
int flag = 0;
String ipString = "";
String state = "";
for (Iterator it2 = reStrings.iterator(); it2.hasNext();) {
String line = (String) it2.next();
line=line.replaceAll(" +", " ");
String keyValue[] = line.split(":");
if (keyValue[0].equals("Hostname")) {
if (keyValue.length < 2) {
log.error("1105 command get result is wrong");
continue;
}
ipString = keyValue[1].replaceAll(" ", "");
flag = 1;
} else if (flag == 1 && keyValue[0].equals("State")) {
if (keyValue.length < 2) {
log.error("1106 command get result is wrong");
continue;
}
state = keyValue[1].replaceAll(" ", "");
flag = 0;
peerIps.put(ipString, state);
}
}
return peerIps;
}
/**
* 根据给定的ip获的ip的状态，即是否在集群中并联通
* 如果ip不在集群中，返回null
* 如果ip在集群中且联通状态为PeerinCluster(Connected)
* 如果ip在集群中且但不连通为PeerinCluster(Disconnected)
* @param peerip
* @return
* @see [类、类#方法、类#成员]
*/
public String getPeerStatus(String peerip){
Map<String, String> peerIps=showClusterInfo();
if(peerIps==null || peerIps.size()==0){
return null;
}
if(!peerIps.containsKey(peerip)){
return Constant.peerincluster_disconnected;
}
return peerIps.get(peerip);
}
public static void main(String[] args) {
PropertyConfigurator.configure("log4j.properties");
System.out.println(new ClusterInfo().showClusterInfo());
}
}

242
src/com/platform/glusterfs/GetTreeData.java
Unescape View File

@ -1,122 +1,120 @@
package com.platform.glusterfs;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.junit.Test;
import com.platform.entities.FolderNode;
import com.platform.utils.Constant;
import com.platform.utils.FileOperateHelper;
import com.platform.utils.GanymedSSH;
/**
* <一句话功能简述> 获得GFS某个目录下的子目录
* <功能详细描述>
* @author chen
* @version [版本号，2016年9月8日]
* @see [相关类/方法]
* @since [产品/模块版本]
*/
public class GetTreeData {
ShowData showData = new ShowData();
/**
* <一句话功能简述> 获得所以子目录
* <功能详细描述>
* @param name
* @return
* @see [类、类#方法、类#成员]
*/
public FolderNode getDatas(String name) {
String names[]=name.split("/");
String only_name=names[names.length-1];
FolderNode fileNode = new FolderNode(only_name);
fileNode.setPath(name);
Map<String, String> files = showData.showFolderData(name);
if(files==null || files.size()==0){
return fileNode;
}
fileNode.setIsFolder(files.size());
List<FolderNode> list = new ArrayList<FolderNode>();
fileNode.setChildNodes(list);
for (Map.Entry<String, String> entry : files.entrySet()) {
if(entry.getKey().equals("app")){
continue;
}
int number = Integer.parseInt(entry.getValue());
if (number == 1) {
fileNode.getChildNodes().add(new FolderNode(entry.getKey(), number));
}
if (number > 1) {
FolderNode temp=getDatas(name+"/"+entry.getKey());
fileNode.getChildNodes().add(temp);
}
}
return fileNode;
}
/**
* <一句话功能简述> 获得所以子目录
* <功能详细描述>
* @param name
* @return
* @see [类、类#方法、类#成员]
*/
public FolderNode getDatasWithShell(String name) {
if(name.endsWith("/")){
name=name.substring(0, name.length());
}
String names[]=name.split("/");
String only_name=names[names.length-1];
FolderNode fileNode = new FolderNode(name);
fileNode.setPath(name);
String shellComment=new FileOperateHelper().fileReaderAndendline(Constant.fileGetTreeData);
String sh_path="/getTreedata.sh";
String cmd="echo -e "+shellComment+" > "+sh_path+" & chmod +x "+sh_path;
Constant.ganymedSSH.execCmdWaitAcquiescent(cmd);
// Map<String, String> files = showData.showFolderData(name);
List<String> files=Constant.ganymedSSH.execCmdWaitAcquiescent(sh_path+" "+name);
if(files==null){
return null;
}
if(files.size()==0){
return fileNode;
}
for(String file:files){
}
return fileNode;
}
@Test
public void test_getTreeData() {
GetTreeData getTreeData=new GetTreeData();
FolderNode fileOrFolder=getTreeData.getDatas("/home");
System.out.println(fileOrFolder);
}
}
/*
class FileOrFolder {
String name;
int isFolder; // 1 is file and other integer is folder show children number
List<FileOrFolder> children;
public FileOrFolder(String name) {
// TODO Auto-generated constructor stub
this.name = name;
}
public FileOrFolder(String name, int isFolder) {
// TODO Auto-generated constructor stub
this.name = name;
this.isFolder = isFolder;
}
}
*/
package com.platform.glusterfs;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.junit.Test;
import com.platform.entities.FolderNode;
import com.platform.utils.Constant;
import com.platform.utils.FileOperateHelper;
/**
* <一句话功能简述> 获得GFS某个目录下的子目录
* <功能详细描述>
* @author chen
* @version [版本号，2016年9月8日]
* @see [相关类/方法]
* @since [产品/模块版本]
*/
public class GetTreeData {
ShowData showData = new ShowData();
/**
* <一句话功能简述> 获得所以子目录
* <功能详细描述>
* @param name
* @return
* @see [类、类#方法、类#成员]
*/
public FolderNode getDatas(String name) {
String names[]=name.split("/");
String only_name=names[names.length-1];
FolderNode fileNode = new FolderNode(only_name);
fileNode.setPath(name);
Map<String, String> files = showData.showFolderData(name);
if(files==null || files.size()==0){
return fileNode;
}
fileNode.setIsFolder(files.size());
List<FolderNode> list = new ArrayList<FolderNode>();
fileNode.setChildNodes(list);
for (Map.Entry<String, String> entry : files.entrySet()) {
if(entry.getKey().equals("app")){
continue;
}
int number = Integer.parseInt(entry.getValue());
if (number == 1) {
fileNode.getChildNodes().add(new FolderNode(entry.getKey(), number));
}
if (number > 1) {
FolderNode temp=getDatas(name+"/"+entry.getKey());
fileNode.getChildNodes().add(temp);
}
}
return fileNode;
}
/**
* <一句话功能简述> 获得所以子目录
* <功能详细描述>
* @param name
* @return
* @see [类、类#方法、类#成员]
*/
public FolderNode getDatasWithShell(String name) {
if(name.endsWith("/")){
name=name.substring(0, name.length());
}
String names[]=name.split("/");
String only_name=names[names.length-1];
FolderNode fileNode = new FolderNode(name);
fileNode.setPath(name);
String shellComment=new FileOperateHelper().fileReaderAndendline(Constant.fileGetTreeData);
String sh_path="/getTreedata.sh";
String cmd="echo -e "+shellComment+" > "+sh_path+" & chmod +x "+sh_path;
Constant.ganymedSSH.execCmdWaitAcquiescent(cmd);
// Map<String, String> files = showData.showFolderData(name);
List<String> files=Constant.ganymedSSH.execCmdWaitAcquiescent(sh_path+" "+name);
if(files==null){
return null;
}
if(files.size()==0){
return fileNode;
}
for(String file:files){
}
return fileNode;
}
@Test
public void test_getTreeData() {
GetTreeData getTreeData=new GetTreeData();
FolderNode fileOrFolder=getTreeData.getDatas("/home");
System.out.println(fileOrFolder);
}
}
/*
class FileOrFolder {
String name;
int isFolder; // 1 is file and other integer is folder show children number
List<FileOrFolder> children;
public FileOrFolder(String name) {
// TODO Auto-generated constructor stub
this.name = name;
}
public FileOrFolder(String name, int isFolder) {
// TODO Auto-generated constructor stub
this.name = name;
this.isFolder = isFolder;
}
}
*/

22
src/com/platform/glusterfs/SetCluster.java
Unescape View File

@ -1,11 +1,11 @@
package com.platform.glusterfs;
import org.apache.log4j.Logger;
public class SetCluster {
public static Logger log = Logger.getLogger ( SetCluster.class);
public int addPeer(String peerip){
return 0;
}
}
package com.platform.glusterfs;
import org.apache.log4j.Logger;
public class SetCluster {
public static Logger log = Logger.getLogger ( SetCluster.class);
public int addPeer(String peerip){
return 0;
}
}

993
src/com/platform/glusterfs/SetVolume.java
Unescape View File

@ -1,495 +1,498 @@
/**
* @author 李乾坤
* 进行volume的一系列操作，如创建、开启停止volume，为volume添加或删除brick
*/
package com.platform.glusterfs;
import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import com.platform.utils.Constant;
public class SetVolume {
public static Logger log = Logger.getLogger(SetVolume.class);
/*
* 创建volume 返回值：创建并挂载成功 1
*
*/
public int createVolume(String volumeName, int count, String type, List bricks, String mountPoint) {
log.info("Creat new volume");
// 判断创建volume的条件是否满足
int able = isAbleCreateVolume(volumeName, count, type, bricks, mountPoint);
if (able == 1) {
String command = null;
// 将brics从List变量中提取出来并连接成可以在命令行中使用的格式
String commandarg = concat(bricks);
/*
* verify the type
*/
if (type.equals(Constant.distributed)) {
command = "gluster volume create " + volumeName + " " + commandarg + "force";
} else if (type.equals(Constant.replica) || type.equals(Constant.stripe)) {
command = "gluster volume create " + volumeName + " " + type + " " + count + " " + commandarg + "force";
}
// 执行命令
List<String> reStrings = Constant.ganymedSSH.execCmdWait(Constant.hostIp, Constant.rootUser, Constant.rootPasswd,
Constant.port, command);
// 创建成功时返回信息格式：volume create: volumename success:
if (reStrings == null || reStrings.size() == 0) {
log.error("3106 " + command + " run return error");
return -7;
}
if (reStrings.get(0).contains("volume create: " + volumeName + ": " + "success:")) {
log.info("create volume "+volumeName+" successed!");
// 创建成功则启动并进行挂载
if (startVolume(volumeName) == 0) {
log.info("start volume "+volumeName+" successed!");
if ((new ShowData().showFolderData(mountPoint)) == null) {
Constant.ganymedSSH.execCmdWaitAcquiescent("mkdir " + mountPoint);
}
// 进行挂载
String command3 = "mount -t glusterfs " + Constant.hostIp + ":/" + volumeName + " " + mountPoint;
List<String> reStrings3 = Constant.ganymedSSH.execCmdWait(Constant.hostIp, Constant.rootUser,
Constant.rootPasswd, Constant.port, command3);
// 这里需要添加解析挂载命令返回字符串的语句，由于我的系统有问题，导致挂载成功后返回WARNING: getfattr
// not found, certain checks will be skipped..
// 所以这句代码未经测试
// 成功挂载时没有任何返回信息
if (reStrings3.size() == 0 || reStrings.get(0).contains("GlusterFS is already mounted"))
{
log.info("mount point successed!");
return 1;
}
}
} else {
log.error("3104 volume create failed with error" + reStrings.get(0));
// System.out.println(reStrings.get(0));
return -7;
}
return 1;
} else {
log.error("给出的参数不满足创建条件");
// System.out.println("给出的参数不满足创建条件");
return able;
}
}
/**
* 删除volume
*
* @param volumeName
* @return 1 表示成功 ；-1表示volume name不存在；-2表示停止volume 失败
*/
public int deleteVolume(String volumeName) {
int status = 0;
List<String> volumeNames = new VolumeInfo().showAllVolumeName();
if (!volumeNames.contains(volumeName)) {
log.error("3801 " + volumeName + " is not exists !");
return -1;
}
List<String> mountPoints = new VolumeInfo().getVolumeMountPoint(volumeName);
if (stopVolume(volumeName) != 0) {
log.error("3802 " + volumeName + " stop failed !");
return -2;
}
log.info("stop "+volumeName+" successed!");
for(String mountPoint:mountPoints){
if (mountPoint != null) {
String command = "umount -l " + mountPoint;
Constant.ganymedSSH.execCmdNoWaitAcquiescent(command);
log.info("umount "+mountPoint+" successed!");
}
}
String command="echo -e \"y\"| gluster volume delete "+volumeName;
List<String> reStrings=Constant.ganymedSSH.execCmdWaitAcquiescent(command);
if(reStrings==null || reStrings.size()>0 || !(reStrings.get(0).contains("volume delete: "+volumeName+": success"))){
log.error("3803 : delete volume "+volumeName+" failed !");
return -3;
}
log.info("delete "+volumeName+" successed!");
return 1;
}
/*
* 为指定的volume添加brick,参数中需要指定类型、数量等 返回值：1成功 ;其他失败
* 过程中需要先检查volume是否存在，还需检查给出的brick数量与类型、count是否相符
*/
public int addBrickVolume(String volumeName, List<String> brickName, int count, String type) {
// 检查是否满足添加bricks的条件
int able = isAble(volumeName, count, type, brickName);
if (able != 1) {
return able;
}
String command = "";
log.info("add brick to the specified volume");
String brick = concat(brickName);
if (type.equals(Constant.distributed))
command = "gluster volume add-brick " + volumeName + " " + brick + "force";
else if (type.equals(Constant.replica))
command = "gluster volume add-brick " + volumeName + " " + "replica " + count + " " + brick + "force";
else if (type.equals(Constant.stripe))
command = "gluster volume add-brick " + volumeName + " " + "stripe " + count + " " + brick + "force";
List<String> reStrings = Constant.ganymedSSH.execCmdWait(Constant.hostIp, Constant.rootUser, Constant.rootPasswd,
Constant.port, command);
// 添加成功的返回信息是：volume add-brick: success
if (reStrings != null && reStrings.size() > 0 && reStrings.get(0).contains("volume add-brick: success")) {
log.info("添加brick成功！");
return 1;
} else {
log.error("3205 add brick failed,please check the system");
// System.out.println("3202 add brick failed,please check the system");
return -5;
}
}
/*
* 为指定的volume删除brick,参数中需要指定类型、数量等 返回值：1 成功 ;其他 失败
* 过程中需要先检查volume是否存在，还需检查给出的brick数量与类型、count是否相符
*/
public int deleteBrickVolume(String volumeName, List<String> brickName, int count, String type) {
int able = isAble(volumeName, count, type, brickName);
if (able != 1) {
return able;
}
String command = null;
log.info("delete brick of the specified volume");
String brick = concat(brickName);
if (type.equals(Constant.distributed)) {
command = "echo -e \"y\" | gluster volume remove-brick " + volumeName + " " + brick + " force";
} else if (type.equals(Constant.replica)) {
command = "echo -e \"y\" | gluster volume remove-brick " + volumeName + " repli " + count + " " + brick
+ " force";
} else if (type.equals(Constant.stripe)) {
command = "echo -e \"y\" | gluster volume remove-brick " + volumeName + " stripe " + count + " " + brick
+ " force";
}
if (command == null) {
log.error("3305 remove brick failed,please check the system");
return -5;
}
log.info("即将执行删除命令");
List<String> reStrings = Constant.ganymedSSH.execCmdWait(Constant.hostIp, Constant.rootUser, Constant.rootPasswd,
Constant.port, command);
// System.out.println(reStrings);
log.info("删除命令执行完毕");
// 删除成功的返回信息是“volume remove-brick: success”
if (reStrings.get(0).contains("volume remove-brick: success")) {
{
log.info("删除brick成功");
return 1;
}
} else {
log.error("3305 remove brick failed,please check the system");
return -5;
}
}
/*
* 停止指定volume 参数中需给出volume的名字 返回值： 0 成功 -1 失败
* 需要先检查volume是否存在，然后判断volume的状态是否已经是停止状态
*/
public int stopVolume(String volumeName) {
log.info("stop volume");
// 首先需要判断volume是否存在，调用其他函数返回所有volume的名字
boolean volumeExist = false;
List<String> volume = new VolumeInfo().showAllVolumeName();
for (String temp : volume) {
if (temp.equals(volumeName)) {
volumeExist = true;
break;
}
}
if (!volumeExist) {
// volume不存在
log.error("3501 the volume doesnot exist");
System.out.println("3501 the volume doesnot exist");
return -1;
} else {
// volume存在，则需判断volume的状态是否已经为“stop”
if (new VolumeInfo().getVolumeStatus(volumeName).equals("Stopped")) {
log.error("3502 the volume is already stoped");
System.out.println("3502 the volume is already stoped");
return -1;
} else {
String command = "echo -e \"y\"| gluster volume stop " + volumeName;
List<String> reStrings = Constant.ganymedSSH.execCmdWait(Constant.hostIp, Constant.rootUser, Constant.rootPasswd,
Constant.port, command);
// 标记操作结果：operation = 1 操作成功
// operation = 0 操作失败
int operation = 0;
for (String temp2 : reStrings) {
if (temp2.contains("volume stop: " + volumeName + ": " + "success")) {
operation = 1;
break;
}
System.out.println("operation: " + operation);
}
if (operation == 1) {
return 0;
} else {
log.error("3503 stop " + volumeName + " failed");
System.out.println("3503 stop " + volumeName + " failed");
return -1;
}
}
}
}
/*
* 开启指定volume 参数中需给出volume的名字 返回值： 0 成功 -1 失败
* 需要先检查volume是否存在，然后判断volume的状态是否已经是开启状态
*/
public int startVolume(String volumeName) {
log.info("start volume");
boolean volumeExist = false;
List<String> volume = new VolumeInfo().showAllVolumeName();
for (String temp : volume) {
if (temp.equals(volumeName)) {
volumeExist = true;
break;
}
}
if (volumeExist) {
if (!(new VolumeInfo().getVolumeStatus(volumeName).equals("Started"))) {
String command = "gluster volume start " + volumeName;
int operation = 0;
// 执行命令
List<String> reStrings = Constant.ganymedSSH.execCmdWait(Constant.hostIp, Constant.rootUser, Constant.rootPasswd,
Constant.port, command);
for (String temp2 : reStrings) {
if (temp2.equals("volume start: " + volumeName + ": " + "success")) {
operation = 1;
}
}
if (operation == 1) {
return 0;
} else {
log.error("3602 start volume failed");
System.out.println("3602 start volume failed");
return -1;
}
} else {
log.error("volume已经开启");
System.out.println("volume已经开启");
return -1;
}
} else {
log.error("3601 the volume does not exist");
// System.out.println("3601 the volume does not exist");
return -1;
}
}
// 需要将存于List变量中的brick的位置组装成可以在glusterfs命令行中直接使用的格式
public String concat(List<String> brickName) {
StringBuffer result = new StringBuffer();
int len = brickName.size();
for (int i = 0; i < len; i++) {
result.append(brickName.get(i));
result.append(" ");
}
return result.toString();
}
/*
* 只在创建volume时使用此函数 创建volume时对不同数据卷，brick的数量需要满足和count的关系
* 首先判断它们是否满足关系，在不满足的关系的情况下是肯定无法完成操作的 1:可以创建 ;-1：brick的ip不在集群中或者未连接; -2 -3
* -4 :类型与brick数目不匹配 ; -5 :volumeName 已经存在；-6：挂载点存在且不为空，不能作为挂载点； -7：未知错误
*/
public int isAbleCreateVolume(String volumeName, int count, String type, List<String> bricks, String mountPoint) {
int status = 0;
int length = bricks.size();
if (type.equals(Constant.distributed)) {
if (count != 0) {
log.error("3101 the kind of distributed requires the arg of count to be 0");
return -2;
}
}
if (type.equals(Constant.stripe)) {
if (length % count != 0) {
log.error("3102 the number of bricks should be the same as or the times of the stripe count");
return -3;
}
}
if (type.equals(Constant.replica)) {
if ((length % count) != 0) {
log.error(
"3103 the number of bricks should be the same as the replicate count or the times of replicate count");
return -4;
}
}
Map peer_status = new ClusterInfo().showClusterInfo();
peer_status.put(Constant.hostIp, Constant.peerincluster_connected);
for (String brick : bricks) {
brick = brick.split(":")[0];
if (!(peer_status.containsKey(brick) && peer_status.get(brick).equals(Constant.peerincluster_connected))) {
log.error("3105 birck " + brick + " ip is not in cluster");
return -1;
}
}
List<String> volumeNames = new VolumeInfo().showAllVolumeName();
if(volumeNames==null){
log.error("3108 showAllVolumeName return error");
return -7;
}
if (volumeNames.contains(volumeName)) {
log.error("3106 " + volumeName + " is already exists! ");
return -5;
}
Map datas = new ShowData().showFolderData(mountPoint);
if (datas != null && datas.size() > 0) {
log.error("3107 " + mountPoint + " is not exists or not empty ! ");
return -6;
}
return 1;
}
/**
* 添加或删除volume的brick时，首先需要判断volume是否存在，然后需要判断volume类型、count及brick数目
*
* @param volumeName
* @param count
* @param type
* @param bricks
* @return 1 满足条件，可以添加;-1 :volume name is not exists;-2,-3,-4 类型与brick数量不匹配；
*/
public int isAble(String volumeName, int count, String type, List bricks) {
List<String> volumeNames = new VolumeInfo().showAllVolumeName();
if (!volumeNames.contains(volumeName)) {
log.error("3201：" + volumeName + " is not exists! ");
return -1;
}
int length = bricks.size();
if (type.equals("distribute")) {
if (count == 0)
return 1;
else {
log.error("3202： the kind of distributed requires the arg of count to be 0");
// System.out.println(" the kind of distributed requires the
// arg of count to be 0");
return -2;
}
}
if (type.equals("stripe")) {
if (length % count == 0)
return 1;
else {
log.error("3203： the number of bricks should be the same as or the times of the stripe count");
// System.out.println(" the number of bricks should be the
// same as or the times of the stripe count");
return -3;
}
}
if (type.equals("replicate")) {
if ((length % count) == 0)
return 1;
else {
log.error(
"3204： the number of bricks should be the same as the replicate count or the times of replicate count");
return -4;
}
}
return 1;
}
public static void main(String[] args) {
SetVolume setVolume = new SetVolume();
int operation = 0;
PropertyConfigurator.configure("log4j.properties");
// TODO Auto-generated method stub
// 测试创建volume的代码
List<String> bricksToCreate = new ArrayList<String>();
bricksToCreate.add("192.168.0.110:/v1");
bricksToCreate.add("192.168.0.116:/v1");
operation = setVolume.createVolume("v1", 0, "distributed", bricksToCreate, "/home/v1_point");
// operation = setVolume.deleteVolume("v3");
//
// // 以下是测试添加brick的代码
//
// List<String> bricksToAdd = new ArrayList<String>();
// bricksToAdd.add("192.168.191.23:/v3");
// operation = setVolume.addBrickVolume("v3", bricksToAdd, 0,
// "distribute");
// System.out.println(operation);
// 以下代码是测试删除brick的代码
// List<String> bricksToAdd= new ArrayList<String>();
// bricksToAdd.add("192.168.191.23:/v3");
// operation =
// setVolume.deleteBrickVolume("v3",bricksToAdd,0,"distribute");
// System.out.println(operation);
// 以下是测试start volume的代码
// String volumeToStart = "testcreate" ;
// int startOperation = startVolume(volumeToStart);
// System.out.println(startOperation);
// 以下是测试stop volume
String volumeToStop = "v3";
// int startOperation = setVolume.stopVolume(volumeToStop);
// 以下是测试创建volume并完成挂载的代码
// List<String> bricksToCreate= new ArrayList<String>();
// bricksToCreate.add("192.168.214.135:/home/create");
// bricksToCreate.add("192.168.214.138:/home/create");
//
// int operation =
// createVolume("createAndmount",0,"distribute",bricksToCreate,"/mnt/create");
// System.out.println(operation);
}
}
/**
* @author 李乾坤
* 进行volume的一系列操作，如创建、开启停止volume，为volume添加或删除brick
*/
package com.platform.glusterfs;
import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import com.platform.utils.Constant;
public class SetVolume {
public static Logger log = Logger.getLogger(SetVolume.class);
/*
* 创建volume 返回值：创建并挂载成功 1
*
*/
public int createVolume(String volumeName, int count, String type, List bricks, String mountPoint) {
log.info("Creat new volume");
// 判断创建volume的条件是否满足
int able = isAbleCreateVolume(volumeName, count, type, bricks, mountPoint);
if (able == 1) {
String command = null;
// 将brics从List变量中提取出来并连接成可以在命令行中使用的格式
String commandarg = concat(bricks);
/*
* verify the type
*/
if (type.equals(Constant.distributed)) {
command = "gluster volume create " + volumeName + " " + commandarg + "force";
} else if (type.equals(Constant.replica) || type.equals(Constant.stripe)) {
command = "gluster volume create " + volumeName + " " + type + " " + count + " " + commandarg + "force";
}
// 执行命令
List<String> reStrings = Constant.ganymedSSH.execCmdWait(Constant.hostIp, Constant.rootUser, Constant.rootPasswd,
Constant.port, command);
// 创建成功时返回信息格式：volume create: volumename success:
if (reStrings == null || reStrings.size() == 0) {
log.error("3106 " + command + " run return error");
return -7;
}
if (reStrings.get(0).contains("volume create: " + volumeName + ": " + "success:")) {
log.info("create volume "+volumeName+" successed!");
// 创建成功则启动并进行挂载
if (startVolume(volumeName) == 0) {
log.info("start volume "+volumeName+" successed!");
if ((new ShowData().showFolderData(mountPoint)) == null) {
Constant.ganymedSSH.execCmdWaitAcquiescent("mkdir " + mountPoint);
}
// 进行挂载
String command3 = "mount -t glusterfs " + Constant.hostIp + ":/" + volumeName + " " + mountPoint;
List<String> reStrings3 = Constant.ganymedSSH.execCmdWait(Constant.hostIp, Constant.rootUser,
Constant.rootPasswd, Constant.port, command3);
// 这里需要添加解析挂载命令返回字符串的语句，由于我的系统有问题，导致挂载成功后返回WARNING: getfattr
// not found, certain checks will be skipped..
// 所以这句代码未经测试
// 成功挂载时没有任何返回信息
if (reStrings3.size() == 0 || reStrings.get(0).contains("GlusterFS is already mounted"))
{
log.info("mount point successed!");
return 1;
}
}
} else {
log.error("3104 volume create failed with error" + reStrings.get(0));
// System.out.println(reStrings.get(0));
return -7;
}
return 1;
} else {
log.error("给出的参数不满足创建条件");
// System.out.println("给出的参数不满足创建条件");
return able;
}
}
/**
* 删除volume
*
* @param volumeName
* @return 1 表示成功 ；-1表示volume name不存在；-2表示停止volume 失败
*/
public int deleteVolume(String volumeName) {
int status = 0;
List<String> volumeNames = new VolumeInfo().showAllVolumeName();
if (!volumeNames.contains(volumeName)) {
log.error("3801 " + volumeName + " is not exists !");
return -1;
}
List<String> mountPoints = new VolumeInfo().getVolumeMountPoint(volumeName);
if (stopVolume(volumeName) != 0) {
log.error("3802 " + volumeName + " stop failed !");
return -2;
}
log.info("stop "+volumeName+" successed!");
if (null == mountPoints) {
return -2;
}
for(String mountPoint:mountPoints){
if (mountPoint != null) {
String command = "umount -l " + mountPoint;
Constant.ganymedSSH.execCmdNoWaitAcquiescent(command);
log.info("umount "+mountPoint+" successed!");
}
}
String command="echo -e \"y\"| gluster volume delete "+volumeName;
List<String> reStrings=Constant.ganymedSSH.execCmdWaitAcquiescent(command);
if(reStrings==null || reStrings.size()>0 || !(reStrings.get(0).contains("volume delete: "+volumeName+": success"))){
log.error("3803 : delete volume "+volumeName+" failed !");
return -3;
}
log.info("delete "+volumeName+" successed!");
return 1;
}
/*
* 为指定的volume添加brick,参数中需要指定类型、数量等 返回值：1成功 ;其他失败
* 过程中需要先检查volume是否存在，还需检查给出的brick数量与类型、count是否相符
*/
public int addBrickVolume(String volumeName, List<String> brickName, int count, String type) {
// 检查是否满足添加bricks的条件
int able = isAble(volumeName, count, type, brickName);
if (able != 1) {
return able;
}
String command = "";
log.info("add brick to the specified volume");
String brick = concat(brickName);
if (type.equals(Constant.distributed))
command = "gluster volume add-brick " + volumeName + " " + brick + "force";
else if (type.equals(Constant.replica))
command = "gluster volume add-brick " + volumeName + " " + "replica " + count + " " + brick + "force";
else if (type.equals(Constant.stripe))
command = "gluster volume add-brick " + volumeName + " " + "stripe " + count + " " + brick + "force";
List<String> reStrings = Constant.ganymedSSH.execCmdWait(Constant.hostIp, Constant.rootUser, Constant.rootPasswd,
Constant.port, command);
// 添加成功的返回信息是：volume add-brick: success
if (reStrings != null && reStrings.size() > 0 && reStrings.get(0).contains("volume add-brick: success")) {
log.info("添加brick成功！");
return 1;
} else {
log.error("3205 add brick failed,please check the system");
// System.out.println("3202 add brick failed,please check the system");
return -5;
}
}
/*
* 为指定的volume删除brick,参数中需要指定类型、数量等 返回值：1 成功 ;其他 失败
* 过程中需要先检查volume是否存在，还需检查给出的brick数量与类型、count是否相符
*/
public int deleteBrickVolume(String volumeName, List<String> brickName, int count, String type) {
int able = isAble(volumeName, count, type, brickName);
if (able != 1) {
return able;
}
String command = null;
log.info("delete brick of the specified volume");
String brick = concat(brickName);
if (type.equals(Constant.distributed)) {
command = "echo -e \"y\" | gluster volume remove-brick " + volumeName + " " + brick + " force";
} else if (type.equals(Constant.replica)) {
command = "echo -e \"y\" | gluster volume remove-brick " + volumeName + " repli " + count + " " + brick
+ " force";
} else if (type.equals(Constant.stripe)) {
command = "echo -e \"y\" | gluster volume remove-brick " + volumeName + " stripe " + count + " " + brick
+ " force";
}
if (command == null) {
log.error("3305 remove brick failed,please check the system");
return -5;
}
log.info("即将执行删除命令");
List<String> reStrings = Constant.ganymedSSH.execCmdWait(Constant.hostIp, Constant.rootUser, Constant.rootPasswd,
Constant.port, command);
// System.out.println(reStrings);
log.info("删除命令执行完毕");
// 删除成功的返回信息是“volume remove-brick: success”
if (reStrings.get(0).contains("volume remove-brick: success")) {
{
log.info("删除brick成功");
return 1;
}
} else {
log.error("3305 remove brick failed,please check the system");
return -5;
}
}
/*
* 停止指定volume 参数中需给出volume的名字 返回值： 0 成功 -1 失败
* 需要先检查volume是否存在，然后判断volume的状态是否已经是停止状态
*/
public int stopVolume(String volumeName) {
log.info("stop volume");
// 首先需要判断volume是否存在，调用其他函数返回所有volume的名字
boolean volumeExist = false;
List<String> volume = new VolumeInfo().showAllVolumeName();
for (String temp : volume) {
if (temp.equals(volumeName)) {
volumeExist = true;
break;
}
}
if (!volumeExist) {
// volume不存在
log.error("3501 the volume doesnot exist");
System.out.println("3501 the volume doesnot exist");
return -1;
} else {
// volume存在，则需判断volume的状态是否已经为“stop”
if (new VolumeInfo().getVolumeStatus(volumeName).equals("Stopped")) {
log.error("3502 the volume is already stoped");
System.out.println("3502 the volume is already stoped");
return -1;
} else {
String command = "echo -e \"y\"| gluster volume stop " + volumeName;
List<String> reStrings = Constant.ganymedSSH.execCmdWait(Constant.hostIp, Constant.rootUser, Constant.rootPasswd,
Constant.port, command);
// 标记操作结果：operation = 1 操作成功
// operation = 0 操作失败
int operation = 0;
for (String temp2 : reStrings) {
if (temp2.contains("volume stop: " + volumeName + ": " + "success")) {
operation = 1;
break;
}
System.out.println("operation: " + operation);
}
if (operation == 1) {
return 0;
} else {
log.error("3503 stop " + volumeName + " failed");
System.out.println("3503 stop " + volumeName + " failed");
return -1;
}
}
}
}
/*
* 开启指定volume 参数中需给出volume的名字 返回值： 0 成功 -1 失败
* 需要先检查volume是否存在，然后判断volume的状态是否已经是开启状态
*/
public int startVolume(String volumeName) {
log.info("start volume");
boolean volumeExist = false;
List<String> volume = new VolumeInfo().showAllVolumeName();
for (String temp : volume) {
if (temp.equals(volumeName)) {
volumeExist = true;
break;
}
}
if (volumeExist) {
if (!(new VolumeInfo().getVolumeStatus(volumeName).equals("Started"))) {
String command = "gluster volume start " + volumeName;
int operation = 0;
// 执行命令
List<String> reStrings = Constant.ganymedSSH.execCmdWait(Constant.hostIp, Constant.rootUser, Constant.rootPasswd,
Constant.port, command);
for (String temp2 : reStrings) {
if (temp2.equals("volume start: " + volumeName + ": " + "success")) {
operation = 1;
}
}
if (operation == 1) {
return 0;
} else {
log.error("3602 start volume failed");
System.out.println("3602 start volume failed");
return -1;
}
} else {
log.error("volume已经开启");
System.out.println("volume已经开启");
return -1;
}
} else {
log.error("3601 the volume does not exist");
// System.out.println("3601 the volume does not exist");
return -1;
}
}
// 需要将存于List变量中的brick的位置组装成可以在glusterfs命令行中直接使用的格式
public String concat(List<String> brickName) {
StringBuffer result = new StringBuffer();
int len = brickName.size();
for (int i = 0; i < len; i++) {
result.append(brickName.get(i));
result.append(" ");
}
return result.toString();
}
/*
* 只在创建volume时使用此函数 创建volume时对不同数据卷，brick的数量需要满足和count的关系
* 首先判断它们是否满足关系，在不满足的关系的情况下是肯定无法完成操作的 1:可以创建 ;-1：brick的ip不在集群中或者未连接; -2 -3
* -4 :类型与brick数目不匹配 ; -5 :volumeName 已经存在；-6：挂载点存在且不为空，不能作为挂载点； -7：未知错误
*/
public int isAbleCreateVolume(String volumeName, int count, String type, List<String> bricks, String mountPoint) {
int status = 0;
int length = bricks.size();
if (type.equals(Constant.distributed)) {
if (count != 0) {
log.error("3101 the kind of distributed requires the arg of count to be 0");
return -2;
}
}
if (type.equals(Constant.stripe)) {
if (length % count != 0) {
log.error("3102 the number of bricks should be the same as or the times of the stripe count");
return -3;
}
}
if (type.equals(Constant.replica)) {
if ((length % count) != 0) {
log.error(
"3103 the number of bricks should be the same as the replicate count or the times of replicate count");
return -4;
}
}
Map peer_status = new ClusterInfo().showClusterInfo();
peer_status.put(Constant.hostIp, Constant.peerincluster_connected);
for (String brick : bricks) {
brick = brick.split(":")[0];
if (!(peer_status.containsKey(brick) && peer_status.get(brick).equals(Constant.peerincluster_connected))) {
log.error("3105 birck " + brick + " ip is not in cluster");
return -1;
}
}
List<String> volumeNames = new VolumeInfo().showAllVolumeName();
if(volumeNames==null){
log.error("3108 showAllVolumeName return error");
return -7;
}
if (volumeNames.contains(volumeName)) {
log.error("3106 " + volumeName + " is already exists! ");
return -5;
}
Map datas = new ShowData().showFolderData(mountPoint);
if (datas != null && datas.size() > 0) {
log.error("3107 " + mountPoint + " is not exists or not empty ! ");
return -6;
}
return 1;
}
/**
* 添加或删除volume的brick时，首先需要判断volume是否存在，然后需要判断volume类型、count及brick数目
*
* @param volumeName
* @param count
* @param type
* @param bricks
* @return 1 满足条件，可以添加;-1 :volume name is not exists;-2,-3,-4 类型与brick数量不匹配；
*/
public int isAble(String volumeName, int count, String type, List bricks) {
List<String> volumeNames = new VolumeInfo().showAllVolumeName();
if (!volumeNames.contains(volumeName)) {
log.error("3201：" + volumeName + " is not exists! ");
return -1;
}
int length = bricks.size();
if (type.equals("distribute")) {
if (count == 0)
return 1;
else {
log.error("3202： the kind of distributed requires the arg of count to be 0");
// System.out.println(" the kind of distributed requires the
// arg of count to be 0");
return -2;
}
}
if (type.equals("stripe")) {
if (length % count == 0)
return 1;
else {
log.error("3203： the number of bricks should be the same as or the times of the stripe count");
// System.out.println(" the number of bricks should be the
// same as or the times of the stripe count");
return -3;
}
}
if (type.equals("replicate")) {
if ((length % count) == 0)
return 1;
else {
log.error(
"3204： the number of bricks should be the same as the replicate count or the times of replicate count");
return -4;
}
}
return 1;
}
public static void main(String[] args) {
SetVolume setVolume = new SetVolume();
int operation = 0;
PropertyConfigurator.configure("log4j.properties");
// TODO Auto-generated method stub
// 测试创建volume的代码
List<String> bricksToCreate = new ArrayList<String>();
bricksToCreate.add("192.168.0.110:/v1");
bricksToCreate.add("192.168.0.116:/v1");
operation = setVolume.createVolume("v1", 0, "distributed", bricksToCreate, "/home/v1_point");
// operation = setVolume.deleteVolume("v3");
//
// // 以下是测试添加brick的代码
//
// List<String> bricksToAdd = new ArrayList<String>();
// bricksToAdd.add("192.168.191.23:/v3");
// operation = setVolume.addBrickVolume("v3", bricksToAdd, 0,
// "distribute");
// System.out.println(operation);
// 以下代码是测试删除brick的代码
// List<String> bricksToAdd= new ArrayList<String>();
// bricksToAdd.add("192.168.191.23:/v3");
// operation =
// setVolume.deleteBrickVolume("v3",bricksToAdd,0,"distribute");
// System.out.println(operation);
// 以下是测试start volume的代码
// String volumeToStart = "testcreate" ;
// int startOperation = startVolume(volumeToStart);
// System.out.println(startOperation);
// 以下是测试stop volume
String volumeToStop = "v3";
// int startOperation = setVolume.stopVolume(volumeToStop);
// 以下是测试创建volume并完成挂载的代码
// List<String> bricksToCreate= new ArrayList<String>();
// bricksToCreate.add("192.168.214.135:/home/create");
// bricksToCreate.add("192.168.214.138:/home/create");
//
// int operation =
// createVolume("createAndmount",0,"distribute",bricksToCreate,"/mnt/create");
// System.out.println(operation);
}
}

208
src/com/platform/glusterfs/ShowData.java
Unescape View File

@ -1,105 +1,105 @@
package com.platform.glusterfs;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import org.junit.Test;
import com.platform.utils.Constant;
public class ShowData {
public static Logger log = Logger.getLogger ( ShowData.class);
/**
* get the data of volumeName Map<string s1,string s2> s1 is data name and s2 is type file or folder
* <功能详细描述>
* @param volumeName
* @return
* @see [类、类#方法、类#成员]
*/
public Map<String,String> showVolumeFiles(String volumeName){
log.info("start show the data");
Map<String,String> data_type=new HashMap<String, String>();
/**
* get mount point of volumeName
*/
String folderName=volumeName;
data_type=showFolderData(volumeName);
return data_type;
}
/**
* get the data of folder name
* Map<String,String> is folder name and type 1 is file and others is folder
* @param FolderName
* @return
*/
public Map<String,String> showFolderData(String folderName){
log.info(" start get "+folderName+" data");
Map<String,String> data_type=new HashMap<String, String>();
String command="ls -l "+folderName;
/*
RunCommand runCommand=new RunCommand();
List<String> reStrings=runCommand.runCommandWait(command);
*/
List<String> reStrings = Constant.ganymedSSH.execCmdWait(Constant.hostIp, Constant.rootUser, Constant.rootPasswd, Constant.port, command);
if(reStrings==null){
log.error("2101 command get result is null");
return null;
}
if(reStrings.size()==0){
log.info("2102 the folder is empty");
return data_type;
}
if(reStrings.get(0).contains("No such file or directory")){
log.info("2103 the "+folderName+" is not exists");
return null;
}
/**
* remove first line total number
*/
reStrings.remove(0);
for(Iterator it2 = reStrings.iterator();it2.hasNext();){
String line=(String)it2.next();
line=line.replaceAll(" +", " ");
String keyValue[]=line.split(" ");
if(keyValue.length<9){
log.error("2104 "+line+" length is short");
continue;
}
data_type.put(keyValue[8], keyValue[1]);
}
log.info(" get "+folderName+" data successed");
return data_type;
}
/**
*
* <一句话功能简述>
* <功能详细描述>
* @see [类、类#方法、类#成员]
*/
@Test
public void testShowData(){
System.out.println(showFolderData("/home"));
}
package com.platform.glusterfs;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import org.junit.Test;
import com.platform.utils.Constant;
public class ShowData {
public static Logger log = Logger.getLogger ( ShowData.class);
/**
* get the data of volumeName Map<string s1,string s2> s1 is data name and s2 is type file or folder
* <功能详细描述>
* @param volumeName
* @return
* @see [类、类#方法、类#成员]
*/
public Map<String,String> showVolumeFiles(String volumeName){
log.info("start show the data");
Map<String,String> data_type=new HashMap<String, String>();
/**
* get mount point of volumeName
*/
String folderName=volumeName;
data_type=showFolderData(volumeName);
return data_type;
}
/**
* get the data of folder name
* Map<String,String> is folder name and type 1 is file and others is folder
* @param FolderName
* @return
*/
public Map<String,String> showFolderData(String folderName){
log.info(" start get "+folderName+" data");
Map<String,String> data_type=new HashMap<String, String>();
String command="ls -l "+folderName;
/*
RunCommand runCommand=new RunCommand();
List<String> reStrings=runCommand.runCommandWait(command);
*/
List<String> reStrings = Constant.ganymedSSH.execCmdWait(Constant.hostIp, Constant.rootUser, Constant.rootPasswd, Constant.port, command);
if(reStrings==null){
log.error("2101 command get result is null");
return null;
}
if(reStrings.size()==0){
log.info("2102 the folder is empty");
return data_type;
}
if(reStrings.get(0).contains("No such file or directory")){
log.info("2103 the "+folderName+" is not exists");
return null;
}
/**
* remove first line total number
*/
reStrings.remove(0);
for(Iterator it2 = reStrings.iterator();it2.hasNext();){
String line=(String)it2.next();
line=line.replaceAll(" +", " ");
String keyValue[]=line.split(" ");
if(keyValue.length<9){
log.error("2104 "+line+" length is short");
continue;
}
data_type.put(keyValue[8], keyValue[1]);
}
log.info(" get "+folderName+" data successed");
return data_type;
}
/**
*
* <一句话功能简述>
* <功能详细描述>
* @see [类、类#方法、类#成员]
*/
@Test
public void testShowData(){
System.out.println(showFolderData("/home"));
}
}

659
src/com/platform/glusterfs/VolumeInfo.java
Unescape View File

@ -1,325 +1,334 @@
package com.platform.glusterfs;
import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import org.junit.Test;
import org.omg.CosNaming.NamingContextExtPackage.StringNameHelper;
import com.platform.utils.Constant;
import com.platform.utils.GanymedSSH;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class VolumeInfo {
public static Logger log = Logger.getLogger(VolumeInfo.class);
/**
* 显示所有volume名称
* <功能详细描述>
* @return
* @see [类、类#方法、类#成员]
*/
public List<String> showAllVolumeName() {
log.info("get volume name");
List<String> volNames = new ArrayList<String>();
/*
* String command = "echo \"" + Constant.rootPasswd +
* "\" |sudo -S gluster volume info|grep ^Volume.Name"; RunCommand
* runCommand = new RunCommand(); List<String> reStrings =
* runCommand.runCommandWait(command);
*/
List<String> reStrings = Constant.ganymedSSH.execCmdWait(Constant.hostIp, Constant.rootUser,
Constant.rootPasswd, Constant.port, Constant.glusterVolumeInfo + "|grep ^Volume.Name");
// System.out.println(reStrings);
if (reStrings == null) {
log.error("1401 get result is null");
return null;
}
if (reStrings.size() == 0) {
log.error("1402 get result is nothing");
return null;
}
if (reStrings.get(0).contains(Constant.noVolume)) {
reStrings.clear();
return reStrings;
}
if (!(reStrings.get(0).split(":")[0].contains("Volume Name"))) {
log.error("1403 get result string wrong");
return null;
}
String nameInfo = "";
for (Iterator it = reStrings.iterator(); it.hasNext();) {
String line = (String) it.next();
String str[] = line.split(":");
volNames.add(str[1].replaceAll(" ", ""));
}
return volNames;
}
/**
* 给定参数volume的名称获得volume的类型
* <功能详细描述>
* @param volumeName
* @return
* @see [类、类#方法、类#成员]
*/
public String getVolumeType(String volumeName) {
log.info("get volume type");
String volType = "";
List<String> reStrings = Constant.ganymedSSH.execCmdWait(Constant.hostIp, Constant.rootUser,
Constant.rootPasswd, Constant.port, Constant.glusterVolumeInfo + volumeName + "|grep ^Type");
// System.out.println(reStrings);
if (reStrings == null) {
log.error("1501 get result is null");
return null;
}
if (reStrings.size() == 0) {
log.error("1502 get result is nothing");
return null;
}
if (!(reStrings.get(0).split(":")[0].contains("Type"))) {
log.error("1503 get result string wrong");
return null;
}
// System.out.println(reStrings);
for (Iterator it = reStrings.iterator(); it.hasNext();) {
String line = (String) it.next();
String str[] = line.split(":");
volType = str[1];
}
volType = volType.replaceAll(" ", "");
return volType;
}
public String getVolumeStatus(String volumeName) {
log.info("get volume status");
String volStatus = "";
List<String> reStrings = Constant.ganymedSSH.execCmdWait(Constant.hostIp, Constant.rootUser,
Constant.rootPasswd, Constant.port, Constant.glusterVolumeInfo + "|grep ^Status");
// System.out.println(reStrings);
if (reStrings == null) {
log.error("1701 get result is null");
return null;
}
if (reStrings.size() == 0) {
log.error("1702 get result is nothing");
return null;
}
if (!(reStrings.get(0).split(":")[0].contains("Status"))) {
log.error("1703 get result string wrong");
return null;
}
for (Iterator it = reStrings.iterator(); it.hasNext();) {
String line = (String) it.next();
String str[] = line.split(":");
volStatus = str[1].replaceAll(" ", "");
}
return volStatus;
}
public Double getVolumeAllSize(String volumeName) {
log.info("get volume allSize");
Double allSize = null;
List<String> reStrings = Constant.ganymedSSH.execCmdWait(Constant.hostIp, Constant.rootUser,
Constant.rootPasswd, Constant.port, Constant.df + "|grep " + volumeName + "|awk '{print $2}'");
// System.out.println(reStrings);
if (reStrings == null) {
log.error("1801 get result is null");
return null;
}
if (reStrings.size() == 0) {
log.error("1802 get result is nothing");
return null;
}
/*
* char flag = reStrings.get(0).trim().toCharArray()[0]; if (flag < 48
* || flag > 57) { log.error("1803 get result string wrong"); return
* null; }
*/
for (Iterator it = reStrings.iterator(); it.hasNext();) {
String line = (String) it.next();
String str[] = line.split("[^0-9]");
allSize = Double.parseDouble(str[0]);
}
return allSize;
}
public Double getVolumeUseSize(String volumeName) {
log.info("get volume used size");
Double usedSize = null;
List<String> reStrings = Constant.ganymedSSH.execCmdWait(Constant.hostIp, Constant.rootUser,
Constant.rootPasswd, Constant.port, Constant.df + "|grep " + volumeName + "|awk '{print $3}'");
// System.out.println(reStrings);
if (reStrings == null) {
log.error("1901 get result is null");
return null;
}
if (reStrings.size() == 0) {
log.error("1902 get result is nothing");
return null;
}
char flag = reStrings.get(0).trim().toCharArray()[0];
if (flag < 48 || flag > 57) {
log.error("1903 get result string wrong");
return null;
}
for (Iterator it = reStrings.iterator(); it.hasNext();) {
String line = (String) it.next();
String str[] = line.split("[^0-9]");
usedSize = Double.parseDouble(str[0]);
}
return usedSize;
}
/**
* @param volumeName
* @return String ipAndpath[] = brick.split(":");
String ip = ipAndpath[0];
String path = ipAndpath[1];
*/
public List<String> getVolumeBricks(String volumeName) {
log.info("get volume bricks");
String cmd = "gluster volume info " + volumeName + " |grep ^Brick'[0-9]\\+' |awk '{print $2}'";
List<String> reStrings = Constant.ganymedSSH.execCmdWaitAcquiescent(cmd);
// System.out.println(reStrings);
if (reStrings == null) {
log.error("1601 get volume bricks wrong");
return null;
}
return reStrings;
}
public List<String> getVolumeMountPoint(String volumeName) {
log.info("get volume MountPoint");
List<String> reStrings = Constant.ganymedSSH.execCmdWait(Constant.hostIp, Constant.rootUser, Constant.rootPasswd,
Constant.port, Constant.df + "|grep " + volumeName + "|awk '{print $6}'");
// System.out.println(reStrings);
if(reStrings==null){
log.error("11001 get result string wrong");
return null;
}
if(reStrings.size()==0){
log.error("11002 "+volumeName+" is no mountpoint");
return null;
}
char flag = reStrings.get(0).trim().toCharArray()[0];
if (flag != '/') {
log.error("11003 get result string wrong");
return null;
}
List<String> mountPoints = new ArrayList<>();
for(String mountPoint:reStrings){
mountPoint=mountPoint.replaceAll(" ", "");
mountPoints.add(mountPoint);
}
return mountPoints;
}
public Map<String, Double> getVolumebricksDataSize(String volumeName) {
List<String> bricks = getVolumeBricks(volumeName);
Map<String, Double> brick_size = new HashMap<>();
if (bricks == null) {
return null;
}
for (String brick : bricks) {
String ipAndpath[] = brick.split(":");
String ip = ipAndpath[0];
String path = ipAndpath[1];
String cmd = "du -d 0 " + path + "|awk '{print $1}'";
List<String> reStrings = Constant.ganymedSSH.execCmdWait(ip, Constant.rootUser, Constant.rootPasswd,
Constant.port, cmd);
// System.out.println(reStrings);
if (reStrings == null) {
log.error("1901 get result is null");
return null;
}
if (reStrings.size() == 0) {
log.error("1902 get result is nothing");
return null;
}
Pattern pattern = Pattern.compile("[0-9]*");
Matcher isNum = pattern.matcher(reStrings.get(0));
if (!isNum.matches()) {
log.error("1903 " + reStrings.get(0) + " is unexpect");
return null;
}
brick_size.put(brick, Double.parseDouble(reStrings.get(0)));
}
return brick_size;
}
public Map<String, Double> getVolumebricksAvailableSize(String volumeName) {
List<String> bricks = getVolumeBricks(volumeName);
Map<String, Double> brick_size = new HashMap<>();
if (bricks == null) {
return null;
}
for (String brick : bricks) {
String ipAndpath[] = brick.split(":");
String ip = ipAndpath[0];
String path = ipAndpath[1];
String cmd = "df " + path + "|awk '{print $4}'";
List<String> reStrings = Constant.ganymedSSH.execCmdWait(ip, Constant.rootUser, Constant.rootPasswd,
Constant.port, cmd);
// System.out.println(reStrings);
if (reStrings == null) {
log.error("1901 get result is null");
return null;
}
if (reStrings.size() == 0) {
log.error("1902 get result is nothing");
return null;
}
Pattern pattern = Pattern.compile("[0-9]*");
Matcher isNum = pattern.matcher(reStrings.get(1));
if (!isNum.matches()) {
log.error("1903 " + reStrings.get(1) + " is unexpect");
return null;
}
brick_size.put(brick, Double.parseDouble(reStrings.get(1)));
}
return brick_size;
}
@Test
public void test_getVolumebricksDataSize() {
System.out.println(getVolumebricksDataSize("gfs_ftp"));
}
@Test
public void test_getVolumebricksAvailableSize() {
System.out.println(getVolumebricksAvailableSize("gfs_ftp"));
}
// @Test
public void test_getVolumeBricks() {
getVolumeBricks("gfs_ftp");
}
}
package com.platform.glusterfs;
import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import org.junit.Test;
import org.omg.CosNaming.NamingContextExtPackage.StringNameHelper;
import com.platform.utils.Constant;
import com.platform.utils.GanymedSSH;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class VolumeInfo {
public static Logger log = Logger.getLogger(VolumeInfo.class);
/**
* 显示所有volume名称
* <功能详细描述>
* @return
* @see [类、类#方法、类#成员]
*/
public List<String> showAllVolumeName() {
log.info("get volume name");
List<String> volNames = new ArrayList<String>();
/*
* String command = "echo \"" + Constant.rootPasswd +
* "\" |sudo -S gluster volume info|grep ^Volume.Name"; RunCommand
* runCommand = new RunCommand(); List<String> reStrings =
* runCommand.runCommandWait(command);
*/
List<String> reStrings = Constant.ganymedSSH.execCmdWait(Constant.hostIp, Constant.rootUser,
Constant.rootPasswd, Constant.port, Constant.glusterVolumeInfo + "|grep ^Volume.Name");
// System.out.println(reStrings);
if (reStrings == null) {
log.error("1401 get result is null");
return null;
}
if (reStrings.size() == 0) {
log.error("1402 get result is nothing");
return null;
}
if (reStrings.get(0).contains(Constant.noVolume)) {
reStrings.clear();
return reStrings;
}
if (!(reStrings.get(0).split(":")[0].contains("Volume Name"))) {
log.error("1403 get result string wrong");
return null;
}
String nameInfo = "";
for (Iterator it = reStrings.iterator(); it.hasNext();) {
String line = (String) it.next();
String str[] = line.split(":");
volNames.add(str[1].replaceAll(" ", ""));
}
return volNames;
}
/**
* 给定参数volume的名称获得volume的类型
* <功能详细描述>
* @param volumeName
* @return
* @see [类、类#方法、类#成员]
*/
public String getVolumeType(String volumeName) {
log.info("get volume type");
String volType = "";
List<String> reStrings = Constant.ganymedSSH.execCmdWait(Constant.hostIp, Constant.rootUser,
Constant.rootPasswd, Constant.port, Constant.glusterVolumeInfo + volumeName + "|grep ^Type");
// System.out.println(reStrings);
if (reStrings == null) {
log.error("1501 get result is null");
return null;
}
if (reStrings.size() == 0) {
log.error("1502 get result is nothing");
return null;
}
if (!(reStrings.get(0).split(":")[0].contains("Type"))) {
log.error("1503 get result string wrong");
return null;
}
// System.out.println(reStrings);
for (Iterator it = reStrings.iterator(); it.hasNext();) {
String line = (String) it.next();
String str[] = line.split(":");
volType = str[1];
}
volType = volType.replaceAll(" ", "");
return volType;
}
public String getVolumeStatus(String volumeName) {
log.info("get volume status");
String volStatus = "";
List<String> reStrings = Constant.ganymedSSH.execCmdWait(Constant.hostIp, Constant.rootUser,
Constant.rootPasswd, Constant.port, Constant.glusterVolumeInfo + "|grep ^Status");
// System.out.println(reStrings);
if (reStrings == null) {
log.error("1701 get result is null");
return null;
}
if (reStrings.size() == 0) {
log.error("1702 get result is nothing");
return null;
}
if (!(reStrings.get(0).split(":")[0].contains("Status"))) {
log.error("1703 get result string wrong");
return null;
}
for (Iterator it = reStrings.iterator(); it.hasNext();) {
String line = (String) it.next();
String str[] = line.split(":");
volStatus = str[1].replaceAll(" ", "");
}
return volStatus;
}
public Double getVolumeAllSize(String volumeName) {
log.info("get volume allSize");
Double allSize = null;
/*
* ======= // waiting for testing... public Double
* getVolumeAllSize(String volumeName) { log.info("get volume allSize");
* Double allSize = null;
*
* >>>>>>> origin/AlexKie String command = "echo \"" +
* Constant.rootPasswd + "\" |sudo -S df -h|grep " + volumeName +
* "|awk '{print $2}'"; RunCommand runCommand = new RunCommand();
* List<String> reStrings = runCommand.runCommandWait(command); <<<<<<<
* HEAD
*/
List<String> reStrings = Constant.ganymedSSH.execCmdWait(Constant.hostIp, Constant.rootUser, Constant.rootPasswd,
Constant.port, Constant.df + "|grep " + volumeName + "|awk '{print $2}'");
// System.out.println(reStrings);
if(reStrings==null){
log.error("1801 get result is null");
return null;
}
if(reStrings.size()==0){
log.error("1802 get result is nothing");
return null;
}
char flag = reStrings.get(0).trim().toCharArray()[0];
if (flag < 48 || flag > 57) {
log.error("1803 get result string wrong");
return null;
}
for (Iterator it = reStrings.iterator(); it.hasNext();) {
String line = (String) it.next();
String str[] = line.split("[^0-9]");
allSize = Double.parseDouble(str[0]);
}
return allSize;
}
public Double getVolumeUseSize(String volumeName) {
log.info("get volume used size");
Double usedSize = null;
List<String> reStrings = Constant.ganymedSSH.execCmdWait(Constant.hostIp, Constant.rootUser,
Constant.rootPasswd, Constant.port, Constant.df + "|grep " + volumeName + "|awk '{print $3}'");
// System.out.println(reStrings);
if (reStrings == null) {
log.error("1901 get result is null");
return null;
}
if (reStrings.size() == 0) {
log.error("1902 get result is nothing");
return null;
}
char flag = reStrings.get(0).trim().toCharArray()[0];
if (flag < 48 || flag > 57) {
log.error("1903 get result string wrong");
return null;
}
for (Iterator it = reStrings.iterator(); it.hasNext();) {
String line = (String) it.next();
String str[] = line.split("[^0-9]");
usedSize = Double.parseDouble(str[0]);
}
return usedSize;
}
/**
* @param volumeName
* @return String ipAndpath[] = brick.split(":");
String ip = ipAndpath[0];
String path = ipAndpath[1];
*/
public List<String> getVolumeBricks(String volumeName) {
log.info("get volume bricks");
String cmd = "gluster volume info " + volumeName + " |grep ^Brick'[0-9]\\+' |awk '{print $2}'";
List<String> reStrings = Constant.ganymedSSH.execCmdWaitAcquiescent(cmd);
// System.out.println(reStrings);
if (reStrings == null) {
log.error("1601 get volume bricks wrong");
return null;
}
return reStrings;
}
public List<String> getVolumeMountPoint(String volumeName) {
log.info("get volume MountPoint");
List<String> reStrings = Constant.ganymedSSH.execCmdWait(Constant.hostIp, Constant.rootUser, Constant.rootPasswd,
Constant.port, Constant.df + "|grep " + volumeName + "|awk '{print $6}'");
// System.out.println(reStrings);
if(reStrings==null){
log.error("11001 get result string wrong");
return null;
}
if(reStrings.size()==0){
log.error("11002 "+volumeName+" is no mountpoint");
return null;
}
char flag = reStrings.get(0).trim().toCharArray()[0];
if (flag != '/') {
log.error("11003 get result string wrong");
return null;
}
List<String> mountPoints = new ArrayList<>();
for(String mountPoint:reStrings){
mountPoint=mountPoint.replaceAll(" ", "");
mountPoints.add(mountPoint);
}
return mountPoints;
}
public Map<String, Double> getVolumebricksDataSize(String volumeName) {
List<String> bricks = getVolumeBricks(volumeName);
Map<String, Double> brick_size = new HashMap<>();
if (bricks == null) {
return null;
}
for (String brick : bricks) {
String ipAndpath[] = brick.split(":");
String ip = ipAndpath[0];
String path = ipAndpath[1];
String cmd = "du -d 0 " + path + "|awk '{print $1}'";
List<String> reStrings = Constant.ganymedSSH.execCmdWait(ip, Constant.rootUser, Constant.rootPasswd,
Constant.port, cmd);
// System.out.println(reStrings);
if (reStrings == null) {
log.error("1901 get result is null");
return null;
}
if (reStrings.size() == 0) {
log.error("1902 get result is nothing");
return null;
}
Pattern pattern = Pattern.compile("[0-9]*");
Matcher isNum = pattern.matcher(reStrings.get(0));
if (!isNum.matches()) {
log.error("1903 " + reStrings.get(0) + " is unexpect");
return null;
}
brick_size.put(brick, Double.parseDouble(reStrings.get(0)));
}
return brick_size;
}
public Map<String, Double> getVolumebricksAvailableSize(String volumeName) {
List<String> bricks = getVolumeBricks(volumeName);
Map<String, Double> brick_size = new HashMap<>();
if (bricks == null) {
return null;
}
for (String brick : bricks) {
String ipAndpath[] = brick.split(":");
String ip = ipAndpath[0];
String path = ipAndpath[1];
String cmd = "df " + path + "|awk '{print $4}'";
List<String> reStrings = Constant.ganymedSSH.execCmdWait(ip, Constant.rootUser, Constant.rootPasswd,
Constant.port, cmd);
// System.out.println(reStrings);
if (reStrings == null) {
log.error("1901 get result is null");
return null;
}
if (reStrings.size() == 0) {
log.error("1902 get result is nothing");
return null;
}
Pattern pattern = Pattern.compile("[0-9]*");
Matcher isNum = pattern.matcher(reStrings.get(1));
if (!isNum.matches()) {
log.error("1903 " + reStrings.get(1) + " is unexpect");
return null;
}
brick_size.put(brick, Double.parseDouble(reStrings.get(1)));
}
return brick_size;
}
@Test
public void test_getVolumebricksDataSize() {
System.out.println(getVolumebricksDataSize("gfs_ftp"));
}
@Test
public void test_getVolumebricksAvailableSize() {
System.out.println(getVolumebricksAvailableSize("gfs_ftp"));
}
// @Test
public void test_getVolumeBricks() {
getVolumeBricks("gfs_ftp");
}
}

298
src/com/platform/service/impl/GfsServiceImpl.java
Unescape View File

@ -1,149 +1,149 @@
/**
* 文件名 : GfsServiceImpl.java
* 版权 : <版权/公司名>
* 描述 : <描述>
* @author chen
* 版本 : <版本>
* 修改时间： 2016年9月8日
* 修改内容： <修改内容>
*/
package com.platform.service.impl;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.springframework.stereotype.Service;
import com.platform.entities.Brick;
import com.platform.entities.FolderNode;
import com.platform.entities.VolumeEntity;
import com.platform.glusterfs.CopyData;
import com.platform.glusterfs.GetTreeData;
import com.platform.glusterfs.VolumeInfo;
import com.platform.service.IGfsService;
import com.platform.utils.CacheTreeData;
import com.platform.utils.ThreadVolume;
import com.platform.utils.getTreeDataByPath;
/**
* <一句话功能简述> gfs功能实现类
* <功能详细描述>
* @author chen
* @version [版本号，2016年9月8日]
* @see [相关类/方法]
* @since [产品/模块版本]
*/
@Service(value = "gfsService")
public class GfsServiceImpl implements IGfsService {
/** gfs目录树形查询 */
private getTreeDataByPath getFolder = new getTreeDataByPath();
/** 数据迁移实现 */
private CopyData copydata = new CopyData();
/** Volume信息查询 */
private VolumeInfo volumeInfo = new VolumeInfo();
@Override
public FolderNode getFolder(String path) {
FolderNode result = getFolder.findByPath(path);
return result;
}
@Override
public int copyFolder(List<String> srcFolders, String dstFolder, String name)
throws Exception {
int status = 0 ;
if (null != srcFolders) {
for (String string : srcFolders) {
status = copydata.copyFolderFiles(string, dstFolder, name);
}
}
return status;
}
/* (non-Javadoc)
* @see com.platform.service.IGfsService#getAllVolume()
*/
@Override
public List<VolumeEntity> getAllVolumes() throws Exception {
List<VolumeEntity> volumeList = new ArrayList<>();
List<String> volumeNameList = volumeInfo.showAllVolumeName();
if (null == volumeNameList) {
return null;
}
for (String volumeName : volumeNameList) {
VolumeEntity volume = new VolumeEntity();
volume.setName(volumeName);
List<String> path = volumeInfo.getVolumeMountPoint(volumeName);
//默认加载第一个路径
if (null != path && path.size() > 0) {
volume.setPath(path.get(0));
}
volume.setAllSize(volumeInfo.getVolumeAllSize(volumeName));
volume.setUsedSize(volumeInfo.getVolumeUseSize(volumeName));
//TODO 查询brick--
//返回 ip:path
List<String> brickStrs = volumeInfo.getVolumeBricks(volumeName);
//brick已用大小：
Map<String, Double> usedSize = volumeInfo.getVolumebricksDataSize(volumeName);
Map<String, Double> availableSize = volumeInfo.getVolumebricksAvailableSize(volumeName);
List<Brick> brickList = new ArrayList<Brick>();
for (String brickIpPath : brickStrs) {
Brick b = new Brick();
String ipAndpath[] = brickIpPath.split(":");
String brickip = ipAndpath[0];
String brickpath = ipAndpath[1];
//iP , path ,
b.setIp(brickip);
b.setPath(brickpath);
b.setAvailableSize(availableSize.get(brickIpPath));
b.setUsedSize(usedSize.get(brickIpPath));
brickList.add(b);
}
volume.setBrick(brickList);
if (null != volume.getPath()) {
// 获得 folder 目录
volume.setFolder(getFolder(volume.getPath()));
}
volumeList.add(volume);
}
return volumeList;
}
@Override
public VolumeEntity getOneVolume(String volumeName) throws Exception {
VolumeEntity volume = new VolumeEntity();
volume.setName(volumeName);
List<String> path = volumeInfo.getVolumeMountPoint(volumeName);
if (null != path && path.size() > 0) {
volume.setPath(path.get(0));
}
volume.setAllSize(volumeInfo.getVolumeAllSize(volumeName));
volume.setUsedSize(volumeInfo.getVolumeUseSize(volumeName));
// volume.setBrick(brick);
if (null != volume.getPath()) {
volume.setFolder(getFolder(path.get(0)));
}
return volume;
}
@Override
public int moveData(String volumeName, String srcPath, String dstPath)
throws Exception {
int result = copydata.copyFolderFiles(srcPath, dstPath, "app");
return result;
}
@Override
public int deleteData(String volumeName, String srcPath) throws Exception {
// TODO Auto-generated method stub
return 0;
}
}
/**
* 文件名 : GfsServiceImpl.java
* 版权 : <版权/公司名>
* 描述 : <描述>
* @author chen
* 版本 : <版本>
* 修改时间： 2016年9月8日
* 修改内容： <修改内容>
*/
package com.platform.service.impl;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.springframework.stereotype.Service;
import com.platform.entities.Brick;
import com.platform.entities.FolderNode;
import com.platform.entities.VolumeEntity;
import com.platform.glusterfs.CopyData;
import com.platform.glusterfs.GetTreeData;
import com.platform.glusterfs.VolumeInfo;
import com.platform.service.IGfsService;
import com.platform.utils.CacheTreeData;
import com.platform.utils.ThreadVolume;
import com.platform.utils.getTreeDataByPath;
/**
* <一句话功能简述> gfs功能实现类
* <功能详细描述>
* @author chen
* @version [版本号，2016年9月8日]
* @see [相关类/方法]
* @since [产品/模块版本]
*/
@Service(value = "gfsService")
public class GfsServiceImpl implements IGfsService {
/** gfs目录树形查询 */
private getTreeDataByPath getFolder = new getTreeDataByPath();
/** 数据迁移实现 */
private CopyData copydata = new CopyData();
/** Volume信息查询 */
private VolumeInfo volumeInfo = new VolumeInfo();
@Override
public FolderNode getFolder(String path) {
FolderNode result = getFolder.findByPath(path);
return result;
}
@Override
public int copyFolder(List<String> srcFolders, String dstFolder, String name)
throws Exception {
int status = 0 ;
if (null != srcFolders) {
for (String string : srcFolders) {
status = copydata.copyFolderFiles(string, dstFolder, name);
}
}
return status;
}
/* (non-Javadoc)
* @see com.platform.service.IGfsService#getAllVolume()
*/
@Override
public List<VolumeEntity> getAllVolumes() throws Exception {
List<VolumeEntity> volumeList = new ArrayList<>();
List<String> volumeNameList = volumeInfo.showAllVolumeName();
if (null == volumeNameList) {
return null;
}
for (String volumeName : volumeNameList) {
VolumeEntity volume = new VolumeEntity();
volume.setName(volumeName);
List<String> path = volumeInfo.getVolumeMountPoint(volumeName);
//默认加载第一个路径
if (null != path && path.size() > 0) {
volume.setPath(path.get(0));
}
volume.setAllSize(volumeInfo.getVolumeAllSize(volumeName));
volume.setUsedSize(volumeInfo.getVolumeUseSize(volumeName));
//TODO 查询brick--
//返回 ip:path
List<String> brickStrs = volumeInfo.getVolumeBricks(volumeName);
//brick已用大小：
Map<String, Double> usedSize = volumeInfo.getVolumebricksDataSize(volumeName);
Map<String, Double> availableSize = volumeInfo.getVolumebricksAvailableSize(volumeName);
List<Brick> brickList = new ArrayList<Brick>();
for (String brickIpPath : brickStrs) {
Brick b = new Brick();
String ipAndpath[] = brickIpPath.split(":");
String brickip = ipAndpath[0];
String brickpath = ipAndpath[1];
//iP , path ,
b.setIp(brickip);
b.setPath(brickpath);
b.setAvailableSize(availableSize.get(brickIpPath));
b.setUsedSize(usedSize.get(brickIpPath));
brickList.add(b);
}
volume.setBrick(brickList);
if (null != volume.getPath()) {
// 获得 folder 目录
volume.setFolder(getFolder(volume.getPath()));
}
volumeList.add(volume);
}
return volumeList;
}
@Override
public VolumeEntity getOneVolume(String volumeName) throws Exception {
VolumeEntity volume = new VolumeEntity();
volume.setName(volumeName);
List<String> path = volumeInfo.getVolumeMountPoint(volumeName);
if (null != path && path.size() > 0) {
volume.setPath(path.get(0));
}
volume.setAllSize(volumeInfo.getVolumeAllSize(volumeName));
volume.setUsedSize(volumeInfo.getVolumeUseSize(volumeName));
// volume.setBrick(brick);
if (null != volume.getPath()) {
volume.setFolder(getFolder(path.get(0)));
}
return volume;
}
@Override
public int moveData(String volumeName, String srcPath, String dstPath)
throws Exception {
int result = copydata.copyFolderFiles(srcPath, dstPath, "app");
return result;
}
@Override
public int deleteData(String volumeName, String srcPath) throws Exception {
// TODO Auto-generated method stub
return 0;
}
}

38
src/com/platform/utils/CacheTreeData.java
Unescape View File

@ -1,19 +1,19 @@
package com.platform.utils;
import java.util.List;
import com.platform.entities.FolderNode;
public class CacheTreeData {
private static List<FolderNode> folders = null;
public static List<FolderNode> getFolders() {
return folders;
}
public static void setFolders(List<FolderNode> folders) {
CacheTreeData.folders = folders;
}
}
package com.platform.utils;
import java.util.List;
import com.platform.entities.FolderNode;
public class CacheTreeData {
private static List<FolderNode> folders = null;
public static List<FolderNode> getFolders() {
return folders;
}
public static void setFolders(List<FolderNode> folders) {
CacheTreeData.folders = folders;
}
}

148
src/com/platform/utils/ConfigsLoader.java
Unescape View File

@ -1,74 +1,74 @@
package com.platform.utils;
import java.util.Properties;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
public class ConfigsLoader implements ServletContextListener {
private static ConfigPropertyReader cReader = null;
@Override
public void contextDestroyed(ServletContextEvent sEvent) {
// TODO Auto-generated method stub
Configs.CONSOLE_LOGGER.info("系统停止..");
}
@SuppressWarnings("static-access")
@Override
public void contextInitialized(ServletContextEvent sEvent) {
// TODO Auto-generated method stub
Configs.CONSOLE_LOGGER.info("系统初始化..");
String contextPath = sEvent.getServletContext().getRealPath("/")
+ "WEB-INF/config/config.properties";
this.cReader = ConfigPropertyReader.Builder(contextPath);
init();
new ThreadVolume("").start();
}
public static void init() {
Properties properties = cReader.getProperties();
Configs.KUBE_MASTER_URL = properties.getProperty("kubeMasterUrl");
Configs.COLLECT_USER_NAME = properties.getProperty("collect-user-name");
Configs.COLLECT_PASSWORD = properties.getProperty("collect-password");
Configs.COLLECT_SERVICE_NAME = properties
.getProperty("collect-service-name");
Configs.GATHER_USER_NAME = properties.getProperty("gather-user-name");
Configs.GATHER_USER_PASSWORD = properties
.getProperty("gather-user-password");
Configs.GATHER_PORT = properties.getProperty("gather-port");
Configs.GATHER_SERVICE_NAME = properties
.getProperty("gather-service-name");
Configs.TABLE_SUFFIX = properties.getProperty("table-suffix");
Configs.EXTRACT_LOG_LOCALTION = properties
.getProperty("extract-log-localtion");
Configs.GATHER_TABLESPACE_NAME = properties
.getProperty("gather-tablespace-name");
Configs.GATHER_TABLESPACE_PATH = properties
.getProperty("gather-tablespace-path");
Configs.GATHER_TABLE_PASSWORD=properties.getProperty("gather-table-user-password");
}
public ConfigPropertyReader getcReader() {
return cReader;
}
@SuppressWarnings("static-access")
public void setcReader(ConfigPropertyReader cReader) {
this.cReader = cReader;
}
}
package com.platform.utils;
import java.util.Properties;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
public class ConfigsLoader implements ServletContextListener {
private static ConfigPropertyReader cReader = null;
@Override
public void contextDestroyed(ServletContextEvent sEvent) {
// TODO Auto-generated method stub
Configs.CONSOLE_LOGGER.info("系统停止..");
}
@SuppressWarnings("static-access")
@Override
public void contextInitialized(ServletContextEvent sEvent) {
// TODO Auto-generated method stub
Configs.CONSOLE_LOGGER.info("系统初始化..");
String contextPath = sEvent.getServletContext().getRealPath("/")
+ "WEB-INF/config/config.properties";
this.cReader = ConfigPropertyReader.Builder(contextPath);
init();
new ThreadVolume("").start();
}
public static void init() {
Properties properties = cReader.getProperties();
Configs.KUBE_MASTER_URL = properties.getProperty("kubeMasterUrl");
Configs.COLLECT_USER_NAME = properties.getProperty("collect-user-name");
Configs.COLLECT_PASSWORD = properties.getProperty("collect-password");
Configs.COLLECT_SERVICE_NAME = properties
.getProperty("collect-service-name");
Configs.GATHER_USER_NAME = properties.getProperty("gather-user-name");
Configs.GATHER_USER_PASSWORD = properties
.getProperty("gather-user-password");
Configs.GATHER_PORT = properties.getProperty("gather-port");
Configs.GATHER_SERVICE_NAME = properties
.getProperty("gather-service-name");
Configs.TABLE_SUFFIX = properties.getProperty("table-suffix");
Configs.EXTRACT_LOG_LOCALTION = properties
.getProperty("extract-log-localtion");
Configs.GATHER_TABLESPACE_NAME = properties
.getProperty("gather-tablespace-name");
Configs.GATHER_TABLESPACE_PATH = properties
.getProperty("gather-tablespace-path");
Configs.GATHER_TABLE_PASSWORD=properties.getProperty("gather-table-user-password");
}
public ConfigPropertyReader getcReader() {
return cReader;
}
@SuppressWarnings("static-access")
public void setcReader(ConfigPropertyReader cReader) {
this.cReader = cReader;
}
}

65
src/com/platform/utils/Constant.java
Unescape View File

@ -1,32 +1,33 @@
package com.platform.utils;
import java.util.List;
public class Constant {
public static String rootUser = "root";
public static String rootPasswd = "root";
public static String hostIp = "192.168.0.116";
// public static String hostIp = "192.168.1.105";
public static int port = 22;
public static String glusterPeerStatus = "gluster peer status";
public static String glusterVolumeInfo = "gluster volume info ";
public static String df = "df -k ";
public static String peerincluster_connected="PeerinCluster(Connected)";
public static String peerincluster_disconnected="PeerinCluster(Disconnected)";
public static String distributed="distributed";
public static String replica="replica";
public static String stripe="stripe";
public static String noVolume="No volumes present";
public static GanymedSSH ganymedSSH=new GanymedSSH(hostIp, rootUser, rootPasswd, port);
public static String fileGetTreeData="./WEB-INF/config/getTreedata.sh";
/**
* volume 获取的线程休眠时间
*/
public final static int get_volume_sleep_time = 300000;
/**
* volume 获取的线程休眠时间
*/
public final static int update_dataInfo_sleep_time = 3000;
}
package com.platform.utils;
import java.util.List;
public class Constant {
public static String rootUser = "root";
public static String rootPasswd = "root";
public static String hostIp = "192.168.0.116";
// public static String hostIp = "192.168.1.105";
public static int port = 22;
public static String glusterPeerStatus = "gluster peer status";
public static String glusterVolumeInfo = "gluster volume info ";
public static String df = "df -k ";
public static String peerincluster_connected="PeerinCluster(Connected)";
public static String peerincluster_disconnected="PeerinCluster(Disconnected)";
public static String distributed="distributed";
public static String replica="replica";
public static String stripe="stripe";
public static String noVolume="No volumes present";
public static GanymedSSH ganymedSSH=new GanymedSSH(hostIp, rootUser, rootPasswd, port);
public static String fileGetTreeData="./WEB-INF/config/getTreedata.sh";
/**
* volume 获取的线程休眠时间
*/
public final static int get_volume_sleep_time = 300000;
/**
* volume 获取的线程休眠时间
*/
public final static int update_dataInfo_sleep_time = 3000;
}

534
src/com/platform/utils/GanymedSSH.java
Unescape View File

@ -1,267 +1,267 @@
package com.platform.utils;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import ch.ethz.ssh2.Connection;
import ch.ethz.ssh2.Session;
import ch.ethz.ssh2.StreamGobbler;
import ch.ethz.ssh2.*;
public class GanymedSSH {
public static Logger log = Logger.getLogger(GanymedSSH.class);
Connection conn;
public boolean status = true;// 锟角凤拷锟斤拷锟街达拷锟斤拷锟斤拷锟阶刺<E998B6>
public GanymedSSH() {
// TODO Auto-generated constructor stub
}
public GanymedSSH(String host, String username, String password, int port) {
// TODO Auto-generated constructor stub
try {
conn = getOpenedConnection(host, username, password, port);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public Connection getOpenedConnection(String host, String username, String password, int port)
throws IOException {
conn = new Connection(host, port);
conn.connect(); // make sure the connection is opened
boolean isAuthenticated = conn.authenticateWithPassword(username, password);
if (isAuthenticated == false)
throw new IOException("Authentication failed.");
return conn;
}
public void execCmdNoWaitAcquiescent(String cmd) {
String host=Constant.hostIp;
String username=Constant.rootUser;
String password=Constant.rootPasswd;
int port=Constant.port;
Session sess = null;
try {
sess = conn.openSession();
// 执锟斤拷cmd
sess.execCommand(cmd);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
sess.close();
}
}
public void execCmdNoWait(String host, String username, String password, int port, String cmd) {
Session sess = null;
try {
conn = getOpenedConnection(host, username, password, port);
sess = conn.openSession();
// 执锟斤拷cmd
sess.execCommand(cmd);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
sess.close();
}
}
public List<String> execCmdWaitAcquiescent(String cmd) {
String host=Constant.hostIp;
String username=Constant.rootUser;
String password=Constant.rootPasswd;
int port=Constant.port;
List<String> reStrings = new ArrayList<String>();
Session sess = null;
try {
sess = conn.openSession();
// 执锟斤拷cmd
sess.execCommand(cmd);
InputStream stdout = new StreamGobbler(sess.getStdout());
InputStream stderr = new StreamGobbler(sess.getStderr());
BufferedReader stdoutReader = new BufferedReader(new InputStreamReader(stdout));
BufferedReader stderrReader = new BufferedReader(new InputStreamReader(stderr));
while (true) {
String line = stdoutReader.readLine();
if (line != null) {
// System.out.println(line);
reStrings.add(line);
} else {
break;
}
}
if(reStrings.size()==0){
while (true) {
String line = stderrReader.readLine();
if (line != null) {
// System.out.println(line);
reStrings.add(line);
} else {
break;
}
}
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
sess.close();
}
return reStrings;
}
public List<String> execCmdWait(String host, String username, String password, int port, String cmd) {
List<String> reStrings = new ArrayList<String>();
Session sess = null;
try {
sess = conn.openSession();
// 执锟斤拷cmd
sess.execCommand(cmd);
InputStream stdout = new StreamGobbler(sess.getStdout());
InputStream stderr = new StreamGobbler(sess.getStderr());
BufferedReader stdoutReader = new BufferedReader(new InputStreamReader(stdout));
BufferedReader stderrReader = new BufferedReader(new InputStreamReader(stderr));
while (true) {
String line = stdoutReader.readLine();
if (line != null) {
// System.out.println(line);
reStrings.add(line);
} else {
break;
}
}
if(reStrings.size()==0){
while (true) {
String line = stderrReader.readLine();
if (line != null) {
// System.out.println(line);
reStrings.add(line);
} else {
break;
}
}
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
sess.close();
}
return reStrings;
}
public Map<String, String> execMD5cmd(String host, String username, String password, int port, String cmd,
String prefix) {
Map<String, String> md5 = new HashMap<String, String>();
Session sess = null;
try {
sess = conn.openSession();
// 执锟斤拷cmd
sess.execCommand(cmd);
InputStream stdout = new StreamGobbler(sess.getStdout());
@SuppressWarnings("resource")
BufferedReader br = new BufferedReader(new InputStreamReader(stdout));
while (true) {
String line = br.readLine();
if (line != null) {
String[] lines = line.split(" ");
String key = lines[1].replace(prefix, "");
String value = lines[0];
md5.put(key, value);
// System.out.println(key+"\t"+value);
} else {
break;
}
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
sess.close();
}
return md5;
}
public String execGetSize(String cmd) {
status = false;
String str_size = "0";
Session sess = null;
try {
// 执锟斤拷cmd
sess = conn.openSession();
sess.execCommand(cmd);
InputStream stdout = new StreamGobbler(sess.getStdout());
@SuppressWarnings("resource")
BufferedReader br = new BufferedReader(new InputStreamReader(stdout));
while (true) {
String line = br.readLine();
if (line != null) {
// String[] lines=line.split(" ");
// str_size=lines[0];
str_size = line;
} else {
break;
}
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
sess.close();
}
status = true;
return str_size;
}
public static void main(String[] args) {
PropertyConfigurator.configure("log4j.properties");
}
}
package com.platform.utils;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import ch.ethz.ssh2.Connection;
import ch.ethz.ssh2.Session;
import ch.ethz.ssh2.StreamGobbler;
import ch.ethz.ssh2.*;
public class GanymedSSH {
public static Logger log = Logger.getLogger(GanymedSSH.class);
Connection conn;
public boolean status = true;// 锟角凤拷锟斤拷锟街达拷锟斤拷锟斤拷锟阶刺<E998B6>
public GanymedSSH() {
// TODO Auto-generated constructor stub
}
public GanymedSSH(String host, String username, String password, int port) {
// TODO Auto-generated constructor stub
try {
conn = getOpenedConnection(host, username, password, port);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public Connection getOpenedConnection(String host, String username, String password, int port)
throws IOException {
conn = new Connection(host, port);
conn.connect(); // make sure the connection is opened
boolean isAuthenticated = conn.authenticateWithPassword(username, password);
if (isAuthenticated == false)
throw new IOException("Authentication failed.");
return conn;
}
public void execCmdNoWaitAcquiescent(String cmd) {
String host=Constant.hostIp;
String username=Constant.rootUser;
String password=Constant.rootPasswd;
int port=Constant.port;
Session sess = null;
try {
conn = getOpenedConnection(host, username, password, port);
sess = conn.openSession();
// 执锟斤拷cmd
sess.execCommand(cmd);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
sess.close();
}
}
public void execCmdNoWait(String host, String username, String password, int port, String cmd) {
Session sess = null;
try {
conn = getOpenedConnection(host, username, password, port);
sess = conn.openSession();
// 执锟斤拷cmd
sess.execCommand(cmd);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
sess.close();
}
}
public List<String> execCmdWaitAcquiescent(String cmd) {
String host=Constant.hostIp;
String username=Constant.rootUser;
String password=Constant.rootPasswd;
int port=Constant.port;
List<String> reStrings = new ArrayList<String>();
Session sess = null;
try {
sess = conn.openSession();
// 执锟斤拷cmd
sess.execCommand(cmd);
InputStream stdout = new StreamGobbler(sess.getStdout());
InputStream stderr = new StreamGobbler(sess.getStderr());
BufferedReader stdoutReader = new BufferedReader(new InputStreamReader(stdout));
BufferedReader stderrReader = new BufferedReader(new InputStreamReader(stderr));
while (true) {
String line = stdoutReader.readLine();
if (line != null) {
// System.out.println(line);
reStrings.add(line);
} else {
break;
}
}
if(reStrings.size()==0){
while (true) {
String line = stderrReader.readLine();
if (line != null) {
// System.out.println(line);
reStrings.add(line);
} else {
break;
}
}
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
sess.close();
}
return reStrings;
}
public List<String> execCmdWait(String host, String username, String password, int port, String cmd) {
List<String> reStrings = new ArrayList<String>();
Session sess = null;
try {
sess = conn.openSession();
// 执锟斤拷cmd
sess.execCommand(cmd);
InputStream stdout = new StreamGobbler(sess.getStdout());
InputStream stderr = new StreamGobbler(sess.getStderr());
BufferedReader stdoutReader = new BufferedReader(new InputStreamReader(stdout));
BufferedReader stderrReader = new BufferedReader(new InputStreamReader(stderr));
while (true) {
String line = stdoutReader.readLine();
if (line != null) {
// System.out.println(line);
reStrings.add(line);
} else {
break;
}
}
if(reStrings.size()==0){
while (true) {
String line = stderrReader.readLine();
if (line != null) {
// System.out.println(line);
reStrings.add(line);
} else {
break;
}
}
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
sess.close();
}
return reStrings;
}
public Map<String, String> execMD5cmd(String host, String username, String password, int port, String cmd,
String prefix) {
Map<String, String> md5 = new HashMap<String, String>();
Session sess = null;
try {
sess = conn.openSession();
// 执锟斤拷cmd
sess.execCommand(cmd);
InputStream stdout = new StreamGobbler(sess.getStdout());
@SuppressWarnings("resource")
BufferedReader br = new BufferedReader(new InputStreamReader(stdout));
while (true) {
String line = br.readLine();
if (line != null) {
String[] lines = line.split(" ");
String key = lines[1].replace(prefix, "");
String value = lines[0];
md5.put(key, value);
// System.out.println(key+"\t"+value);
} else {
break;
}
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
sess.close();
}
return md5;
}
public String execGetSize(String cmd) {
status = false;
String str_size = "0";
Session sess = null;
try {
// 执锟斤拷cmd
sess = conn.openSession();
sess.execCommand(cmd);
InputStream stdout = new StreamGobbler(sess.getStdout());
@SuppressWarnings("resource")
BufferedReader br = new BufferedReader(new InputStreamReader(stdout));
while (true) {
String line = br.readLine();
if (line != null) {
// String[] lines=line.split(" ");
// str_size=lines[0];
str_size = line;
} else {
break;
}
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
sess.close();
}
status = true;
return str_size;
}
public static void main(String[] args) {
PropertyConfigurator.configure("log4j.properties");
}
}

96
src/com/platform/utils/getTreeDataByPath.java
Unescape View File

@ -1,48 +1,48 @@
package com.platform.utils;
import java.util.List;
import com.platform.entities.FolderNode;
public class getTreeDataByPath {
/**
* @param path
* @return
*/
public FolderNode findByPath(String path) {
List<FolderNode> folderNodelist = CacheTreeData.getFolders();
if (null == folderNodelist) {
return null;
}
FolderNode folder = null;
for (FolderNode folderNode : folderNodelist) {
folder = getFolder(folderNode, path);
if (null != folder) {
break;
}
}
return folder;
}
/**
* @param f
* @return
*/
private FolderNode getFolder(FolderNode f, String path){
FolderNode result = null;
if(path.equals(f.getPath())){
return f;
}
List<FolderNode> folds = f.getChildNodes();
if (null != folds) {
for (FolderNode folderNode : folds) {
result = getFolder(folderNode, path);
if (null != result) {
break;
}
}
}
return result;
}
}
package com.platform.utils;
import java.util.List;
import com.platform.entities.FolderNode;
public class getTreeDataByPath {
/**
* @param path
* @return
*/
public FolderNode findByPath(String path) {
List<FolderNode> folderNodelist = CacheTreeData.getFolders();
if (null == folderNodelist) {
return null;
}
FolderNode folder = null;
for (FolderNode folderNode : folderNodelist) {
folder = getFolder(folderNode, path);
if (null != folder) {
break;
}
}
return folder;
}
/**
* @param f
* @return
*/
private FolderNode getFolder(FolderNode f, String path){
FolderNode result = null;
if(path.equals(f.getPath())){
return f;
}
List<FolderNode> folds = f.getChildNodes();
if (null != folds) {
for (FolderNode folderNode : folds) {
result = getFolder(folderNode, path);
if (null != result) {
break;
}
}
}
return result;
}
}

Write Preview
Loading…
Cancel
Save