通过ssh访问linux文件

深碍√TFBOYSˉ_ 2022-05-20 10:24 234阅读 0赞

使用java代码链接Linux服务器，无非使用SSH借用用户名密码进行链接，ganymed jar包提供了ssh的连接方式，下面我们借助Ambari开源项目代码，使用实例获得hadoop的一些配置文件并使用xml工具类进行解析。

pom文件内容，引入ganymed和文本处理类commons-lang3：

<?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <parent>
 <artifactId>java</artifactId>
 <groupId>com.study.java</groupId>
 <version>1.0-SNAPSHOT</version>
 </parent>
 <modelVersion>4.0.0</modelVersion>
 
 <artifactId>utils</artifactId>
 <properties>
 <java.version>1.8</java.version>
 <ganymed-ssh2.version>262</ganymed-ssh2.version>
 <apache-commons.version>3.5</apache-commons.version>
 </properties>
 
 <dependencies>
 <dependency>
 <groupId>ch.ethz.ganymed</groupId>
 <artifactId>ganymed-ssh2</artifactId>
 <version>${ganymed-ssh2.version}</version>
 </dependency>
 <dependency>
 <groupId>org.apache.commons</groupId>
 <artifactId>commons-lang3</artifactId>
 <version>${apache-commons.version}</version>
 </dependency>
 <dependency>
 <groupId>dom4j</groupId>
 <artifactId>dom4j</artifactId>
 <version>1.6.1</version>
 </dependency>
 <dependency>
 <groupId>junit</groupId>
 <artifactId>junit</artifactId>
 <version>4.12</version>
 <scope>test</scope>
 </dependency>
 </dependencies>
 
 </project>

CommandUtils类，getProcess获得进程信息和cat获得xml文件内容：

public class CommandUtils {
    
      private static DecimalFormat dFormat =new DecimalFormat("#.0");
    
      /**
       * 获得进程信息，从进程中得到服务部署地址
       * @param conn
       * @param processName
       * @param pwd
       * @return
       */
      public static String getProcess(Connection conn , String processName , String pwd ){
        String head = processName.substring(0,1);
        String end = processName.substring(1);
        String shellString = String.format( CtrCommond.LinuxCmd.PID , pwd,head,end);
        return  CtrCommond.doCommond(conn,shellString );
      }
    
      /**
       * 使用cat获得到文件内容信息
       * @param conn
       * @param configDir
       * @param pwd
       * @return
       */
      public static String catConfig(Connection conn , String configDir , String pwd ){
    
        String shellString = String.format( CtrCommond.LinuxCmd.Cat , pwd,configDir);
        return  CtrCommond.doCommond(conn,shellString );
      }
    
    }

CtrCommond类用于linux连接和docommand执行命令：

/**
 * Created by whp on 2017/12/28.
 */
 public class CtrCommond {
 
 private static final Logger LOG = LoggerFactory.getLogger(CtrCommond.class);
 
 private static final String id_rsa_path =null;
 /**
 * 获取服务器链接
 */
 public static Connection getConn(String hostName, String userName, int sshPort, String passWord) {
 try {
 Connection conn = new Connection(hostName, sshPort);
 //连接到主机
 conn.connect();
 //使用用户名和密码校验
 boolean isconn = conn.authenticateWithPassword(userName, passWord);
 
 if (!isconn) {
 LOG.info("用户名称或者是密码不正确");
 } else {
 return conn;
 }
 } catch (IOException e) {
 LOG.error("获取服务器链接出现异常：" + e.toString());
 return null;
 }
 return null;
 }
 
 public static Connection getConn(String hostName, String userName, int sshPort,
 char[] pemPrivateKey, String password) {
 try {
 Connection conn = new Connection(hostName, sshPort);
 //连接到主机
 conn.connect();
 //使用PublicKey校验
 boolean isconn = conn.authenticateWithPublicKey(userName, pemPrivateKey, password);
 if (!isconn) {
 LOG.info("用户名称或者是密码不正确");
 } else {
 return conn;
 }
 } catch (IOException e) {
 LOG.error("获取服务器链接出现异常：" + e.toString());
 return null;
 }
 return null;
 }
 
 public static Connection getConn(String hostName, String userName, int sshPort,
 File pemFile, String password) {
 try {
 Connection conn = new Connection(hostName, sshPort);
 //连接到主机
 conn.connect();
 boolean isconn = conn.authenticateWithPublicKey(userName, pemFile, password);
 if (!isconn) {
 LOG.info("用户名称或者是密码不正确");
 } else {
 return conn;
 }
 } catch (IOException e) {
 LOG.error("获取服务器链接出现异常：" + e.toString());
 return null;
 }
 return null;
 }
 
 /**
 * 远程执行命令
 */
 public static String doCommond(Connection conn, String cmd) {
 String result = "";
 try {
 if (conn == null) {
 LOG.info("请先链接服务器");
 } else {
 Session sess = conn.openSession();
 sess.execCommand(cmd);
 InputStream stdout = new StreamGobbler(sess.getStdout());
 BufferedReader stdoutReader = new BufferedReader(new InputStreamReader(stdout));
 while (true) {
 String line = stdoutReader.readLine();
 if (line == null) {
 break;
 }
 result += line + StaticKeys.SPLIT_BR;
 }
 //连接的Session和Connection对象都需要关闭
 stdoutReader.close();
 sess.close();
 }
 } catch (IOException e) {
 LOG.error("执行linux命令错误：" + e.toString());
 }
 if (result.endsWith(StaticKeys.SPLIT_BR)) {
 result = result.substring(0, result.length() - StaticKeys.SPLIT_BR.length());
 }
 
 if (!StringUtils.isEmpty(result)) {
 if (cmd.contains("DEV") || cmd.contains("iostat")) {
 if (result.contains("")) {
 result = result.substring(result.lastIndexOf("") + 10);
 }
 }
 if (cmd.contains("mpstat")) {
 if (result.contains("")) {
 result = result.substring(result.lastIndexOf("") + 10);
 int s = result.indexOf("") + 5;
 s = result.indexOf("", s);
 result = result.substring(0, s);
 }
 }
 }
 return result;
 }
 
 public class LinuxCmd {
 
 /**
 * 根据进程名称查询进程
 */
 public static final String PID = "echo %s | sudo -S ps aux | grep -i [%s]%s ";
 
 
 public static final String Cat = "echo %s | sudo -S cat %s ";
 
 public static final String VIEW_MEM = "free -m";//查看内存状态
 
 public static final String SYSTEM_RELEASE = "cat /etc/system-release";//查看系统版本
 
 public static final String UNAME_A = "uname -a";//查看系统详细信息
 
 public static final String DF_HL = "df -k | grep '^\\/dev/' | awk '{print $2,$3,$4}'";//查看磁盘空间
 
 //物理cpu个数
 public static final String WULI_CPU_NUM = "cat /proc/cpuinfo| grep \"physical id\"| sort| uniq| wc -l";
 
 //每个cpu的核数
 public static final String WULI_CPU_CORE_NUM = "cat /proc/cpuinfo| grep \"cpu cores\"| uniq";
 
 //cpu型号信息
 public static final String CPU_XINGHAO = "cat /proc/cpuinfo | grep name | cut -f2 -d: | uniq -c";
 
 //cpu使用情况
 public static final String VMSTAT = "top -b -n 1 | sed -n '3p'";
 
 //查看服务器网络吞吐率
 public static final String SAR_DEV_1 = "sar -n DEV 1 3";
 
 //查看磁盘IO使用情况
 public static final String DISK_IO = "iostat -xkz 1 1";
 
 //tcp状态
 public static final String SAR_TCP_1 = "sar -n TCP 1 3";
 
 //查看系统负载状态
 public static final String UPTIME = "uptime";
 
 //根据PID查看进程状态
 public static final String dd = "ps aux|head -1;ps aux|grep {pid}";
 
 public static final String rpcinfo = "rpcinfo -p";//看rpc服务开放
 
 public static final String lsmod = "lsmod";//检查系统内核模块
 
 public static final String passwd_update_time = "ls -l /etc/passwd";//查看passwd文件修改时间
 
 public static final String crontab = "cat /etc/crontab";//查看计划任务
 
 public static final String promisc = "ip link | grep promisc";//检查网络：ip link | grep PROMISC（正常网卡不该在promisc模式，可能存在sniffer）
 
 public static final String date = "date \"+%Y-%m-%d %H:%M:%S\"";
 public static final String ntp = "ntpdate ";
 
 public static final String reboot = "reboot ";
 
 public static final String shutdown = "shutdown -h now ";
 }
 
 }

PathUtils类，对于访问路径进行格式化：

/**
     * @author whp 18-7-16
     */
    public class PathUtils {
    
        /**
         * 进程配置转换
         * @param process
         * @param serviceType
         * @return
         */
        public static String parse(String process  , String serviceType) {
            String homeDir ="";
            if(process!=null ) {
                String []javaConfig =  process.split(" ");
                for(String config : javaConfig ) {
                    if(config.contains("-Dhadoop.home.dir") && serviceType.equals("hadoop")) {
                        String []dir = config.split("=");
                        homeDir = dir[1];
                        break;
                    }else if(config.contains("-Dhbase.home.dir") && serviceType.equals("hbase")) {
                        String []dir = config.split("=");
                        homeDir = dir[1];
                        break;
                    }else if( serviceType.equals("hive")) {
                        if(config.contains("-D") || config.contains("-X"))
                            continue;
                        String pattern = "(.*)\\/lib\\/.*$";
                        Pattern r = Pattern.compile(pattern);
                        Matcher m = r.matcher(config);
                        if(m.find()){
                            homeDir= m.group(1);
                            break;
                        }
                    }
                }
            }
            return homeDir;
        }
    }

/**
 */
 public class StaticKeys {
 	
 	public static String SPLIT_BR = "";//换行标识
 	
 	public static String SPLIT_KG = " ";//空格
 	
 	public static String SPLIT_DH = ",";//逗号
 
 	public static String SPLIT_MH = ":";//逗号
 
 	public static String SPLIT_SXG = "//";//双反斜杠
 
 	public static String SPLIT_LINE = "\n";//换行标识
 
 	public static String MAC ="";//本机mac地址
 	
 }

xml格式化类，xml格式化借助于java提供的dom4j，使用document将xml转化为element对象，然后遍历elements将其转化为list，并将element的name作为key值进行保存。

public class XmlMapUtils {
 public static void main(String[] args) throws DocumentException, IOException {
 //		String textFromFile = FileUtils.readFileToString(new File("D:/workspace/workspace_3.7/xml2map/src/xml2json/sample.xml"),"UTF-8");
 //		Map<String, Object> map = xml2map(textFromFile, false);
 //		// long begin = System.currentTimeMillis();
 //		// for(int i=0; i<1000; i++){
 //		// map = (Map<String, Object>) xml2mapWithAttr(doc.getRootElement());
 //		// }
 //		// System.out.println("耗时:"+(System.currentTimeMillis()-begin));
 //		JSON json = JSONObject.fromObject(map);
 //		System.out.println(json.toString(1)); // 格式化输出
 Map<String,Object> map = new HashMap<String, Object>();
 map.put("q", "");
 map.put("w", "");
 map.put("e", "");
 Document doc = map2xml(map, "root");
 //Document doc = map2xml(map); //map中含有根节点的键
 System.out.println(formatXml(doc));
 }
 
 /**
 * xml转map 不带属性
 * @param xmlStr
 * @param needRootKey 是否需要在返回的map里加根节点键
 * @return
 * @throws DocumentException
 */
 public static Map xml2map(String xmlStr, boolean needRootKey) throws DocumentException {
 xmlStr = xmlStr.replace("","");
 Document doc = DocumentHelper.parseText(xmlStr);
 Element root = doc.getRootElement();
 Map<String, Object> map = (Map<String, Object>) xml2map(root);
 if(root.elements().size()==0 && root.attributes().size()==0){
 return map;
 }
 if(needRootKey){
 //在返回的map里加根节点键（如果需要）
 Map<String, Object> rootMap = new HashMap<String, Object>();
 rootMap.put(root.getName(), map);
 return rootMap;
 }
 return map;
 }
 
 /**
 * xml转map 带属性
 * @param xmlStr
 * @param needRootKey 是否需要在返回的map里加根节点键
 * @return
 * @throws DocumentException
 */
 public static Map xml2mapWithAttr(String xmlStr, boolean needRootKey) throws DocumentException {
 Document doc = DocumentHelper.parseText(xmlStr);
 Element root = doc.getRootElement();
 Map<String, Object> map = (Map<String, Object>) xml2mapWithAttr(root);
 if(root.elements().size()==0 && root.attributes().size()==0){
 return map; //根节点只有一个文本内容
 }
 if(needRootKey){
 //在返回的map里加根节点键（如果需要）
 Map<String, Object> rootMap = new HashMap<String, Object>();
 rootMap.put(root.getName(), map);
 return rootMap;
 }
 return map;
 }
 
 /**
 * xml转map 不带属性
 * @param e
 * @return
 */
 private static Map xml2map(Element e) {
 Map map = new LinkedHashMap();
 List list = e.elements();
 if (list.size() > 0) {
 for (int i = 0; i < list.size(); i++) {
 Element iter = (Element) list.get(i);
 List mapList = new ArrayList();
 
 if (iter.elements().size() > 0) {
 Map m = xml2map(iter);
 if (map.get(iter.getName()) != null) {
 Object obj = map.get(iter.getName());
 if (!(obj instanceof List)) {
 mapList = new ArrayList();
 mapList.add(obj);
 mapList.add(m);
 }
 if (obj instanceof List) {
 mapList = (List) obj;
 mapList.add(m);
 }
 map.put(iter.getName(), mapList);
 } else
 map.put(iter.getName(), m);
 } else {
 if (map.get(iter.getName()) != null) {
 Object obj = map.get(iter.getName());
 if (!(obj instanceof List)) {
 mapList = new ArrayList();
 mapList.add(obj);
 mapList.add(iter.getText());
 }
 if (obj instanceof List) {
 mapList = (List) obj;
 mapList.add(iter.getText());
 }
 map.put(iter.getName(), mapList);
 } else
 map.put(iter.getName(), iter.getText());
 }
 }
 } else
 map.put(e.getName(), e.getText());
 return map;
 }
 
 /**
 * xml转map 带属性
 * @param
 * @return
 */
 private static Map xml2mapWithAttr(Element element) {
 Map<String, Object> map = new LinkedHashMap<String, Object>();
 
 List<Element> list = element.elements();
 List<Attribute> listAttr0 = element.attributes(); // 当前节点的所有属性的list
 for (Attribute attr : listAttr0) {
 map.put("@" + attr.getName(), attr.getValue());
 }
 if (list.size() > 0) {
 
 for (int i = 0; i < list.size(); i++) {
 Element iter = list.get(i);
 List mapList = new ArrayList();
 
 if (iter.elements().size() > 0) {
 Map m = xml2mapWithAttr(iter);
 if (map.get(iter.getName()) != null) {
 Object obj = map.get(iter.getName());
 if (!(obj instanceof List)) {
 mapList = new ArrayList();
 mapList.add(obj);
 mapList.add(m);
 }
 if (obj instanceof List) {
 mapList = (List) obj;
 mapList.add(m);
 }
 map.put(iter.getName(), mapList);
 } else
 map.put(iter.getName(), m);
 } else {
 
 List<Attribute> listAttr = iter.attributes(); // 当前节点的所有属性的list
 Map<String, Object> attrMap = null;
 boolean hasAttributes = false;
 if (listAttr.size() > 0) {
 hasAttributes = true;
 attrMap = new LinkedHashMap<String, Object>();
 for (Attribute attr : listAttr) {
 attrMap.put("@" + attr.getName(), attr.getValue());
 }
 }
 
 if (map.get(iter.getName()) != null) {
 Object obj = map.get(iter.getName());
 if (!(obj instanceof List)) {
 mapList = new ArrayList();
 mapList.add(obj);
 // mapList.add(iter.getText());
 if (hasAttributes) {
 attrMap.put("#text", iter.getText());
 mapList.add(attrMap);
 } else {
 mapList.add(iter.getText());
 }
 }
 if (obj instanceof List) {
 mapList = (List) obj;
 // mapList.add(iter.getText());
 if (hasAttributes) {
 attrMap.put("#text", iter.getText());
 mapList.add(attrMap);
 } else {
 mapList.add(iter.getText());
 }
 }
 map.put(iter.getName(), mapList);
 } else {
 // map.put(iter.getName(), iter.getText());
 if (hasAttributes) {
 attrMap.put("#text", iter.getText());
 map.put(iter.getName(), attrMap);
 } else {
 map.put(iter.getName(), iter.getText());
 }
 }
 }
 }
 } else {
 // 根节点的
 if (listAttr0.size() > 0) {
 map.put("#text", element.getText());
 } else {
 map.put(element.getName(), element.getText());
 }
 }
 return map;
 }
 
 /**
 * map转xml map中没有根节点的键
 * @param map
 * @param rootName
 * @throws DocumentException
 * @throws IOException
 */
 public static Document map2xml(Map<String, Object> map, String rootName) throws DocumentException, IOException {
 Document doc = DocumentHelper.createDocument();
 Element root = DocumentHelper.createElement(rootName);
 doc.add(root);
 map2xml(map, root);
 //System.out.println(doc.asXML());
 //System.out.println(formatXml(doc));
 return doc;
 }
 
 /**
 * map转xml map中含有根节点的键
 * @param map
 * @throws DocumentException
 * @throws IOException
 */
 public static Document map2xml(Map<String, Object> map) throws DocumentException, IOException {
 Iterator<Map.Entry<String, Object>> entries = map.entrySet().iterator();
 if(entries.hasNext()){ //获取第一个键创建根节点
 Map.Entry<String, Object> entry = entries.next();
 Document doc = DocumentHelper.createDocument();
 Element root = DocumentHelper.createElement(entry.getKey());
 doc.add(root);
 map2xml((Map)entry.getValue(), root);
 //System.out.println(doc.asXML());
 //System.out.println(formatXml(doc));
 return doc;
 }
 return null;
 }
 
 /**
 * map转xml
 * @param map
 * @param body xml元素
 * @return
 */
 private static Element map2xml(Map<String, Object> map, Element body) {
 Iterator<Map.Entry<String, Object>> entries = map.entrySet().iterator();
 while (entries.hasNext()) {
 Map.Entry<String, Object> entry = entries.next();
 String key = entry.getKey();
 Object value = entry.getValue();
 if(key.startsWith("@")){	//属性
 body.addAttribute(key.substring(1, key.length()), value.toString());
 } else if(key.equals("#text")){	//有属性时的文本
 body.setText(value.toString());
 } else {
 if(value instanceof List ){
 List list = (List)value;
 Object obj;
 for(int i=0; i<list.size(); i++){
 obj = list.get(i);
 //list里是map或String，不会存在list里直接是list的，
 if(obj instanceof Map){
 Element subElement = body.addElement(key);
 map2xml((Map)list.get(i), subElement);
 } else {
 body.addElement(key).setText((String)list.get(i));
 }
 }
 } else if(value instanceof Map ){
 Element subElement = body.addElement(key);
 map2xml((Map)value, subElement);
 } else {
 body.addElement(key).setText(value.toString());
 }
 }
 //System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
 }
 return body;
 }
 
 /**
 * 格式化输出xml
 * @param xmlStr
 * @return
 * @throws DocumentException
 * @throws IOException
 */
 public static String formatXml(String xmlStr) throws DocumentException, IOException {
 Document document = DocumentHelper.parseText(xmlStr);
 return formatXml(document);
 }
 
 /**
 * 格式化输出xml
 * @param document
 * @return
 * @throws DocumentException
 * @throws IOException
 */
 public static String formatXml(Document document) throws DocumentException, IOException {
 // 格式化输出格式
 OutputFormat format = OutputFormat.createPrettyPrint();
 //format.setEncoding("UTF-8");
 StringWriter writer = new StringWriter();
 // 格式化输出流
 XMLWriter xmlWriter = new XMLWriter(writer, format);
 document.getRootElement().asXML();
 // 将document写入到输出流
 xmlWriter.write(document);
 xmlWriter.close();
 return writer.toString();
 }
 
 }

test测试类：

public class LinuxCommondTest {
        private final String HOST="192.168.1.221";
        private final int PORT=22;
        private final String USER_NAME="root";
        private final String PASSWORD="123qwe";
        private final String PROCESS_NAME="namenode";
    
        @Test
        public void testLoadXML(){
            Connection conn= CtrCommond.getConn(HOST,USER_NAME,PORT,PASSWORD);
            String process= CommandUtils.getProcess(conn,PROCESS_NAME,PASSWORD);
            System.out.println("===process=="+process);
            String homeDir= PathUtils.parse(process,"hadoop");
            System.out.println("===homDir=="+homeDir);
            String []hadoopDefaultConfig = {"hdfs-site.xml","core-site.xml","yarn-site.xml","mapred-site.xml"};
            for(String defaultConfig : hadoopDefaultConfig) {
                String configDir = homeDir + "/etc/hadoop/" + defaultConfig;
                String xmlFile = CommandUtils.catConfig(conn, configDir, PASSWORD);
                System.out.println(xmlFile);
            }
        }
    }

文章涉及到xml转化，ssh访问linux系统，command执行linux命令的代码编写，详细工程请参考本人github项目：

[https://github.com/whpHarper/java][https_github.com_whpHarper_java]下面utils子工程。

[https_github.com_whpHarper_java]: https://github.com/whpHarper/java