当前位置: 首页 > news >正文

单网页网站制作关于营销的最新的新闻

单网页网站制作,关于营销的最新的新闻,网上购物最实惠的网站,东莞公司展厅设计公司基础知识 基于如下技术栈开发DevOps平台 Spring Boot Shell Ansible Git Gitlab Docker K8S Vue 1、spring boot starter的封装使用 2、Shell脚本的编写 3、Ansible 脚本的编写 4、Docker 的使用与封装设计 本篇介绍如何使用Java封装Linux命令和Shell脚本的使用 将其设计成…

 基础知识

基于如下技术栈开发DevOps平台

Spring Boot

Shell

Ansible

Git

Gitlab

Docker

K8S

Vue

 1、spring boot starter的封装使用

2、Shell脚本的编写

3、Ansible 脚本的编写

4、Docker 的使用与封装设计

本篇介绍如何使用Java封装Linux命令和Shell脚本的使用

将其设计成spring boot starter

maven依赖pom文件

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.7.9</version><relativePath/> <!-- lookup parent from repository --></parent><groupId>com.devops</groupId><artifactId>ssh-client-pool-spring-boot-starter</artifactId><version>0.0.1-SNAPSHOT</version><name>ssh-client-pool-spring-boot-starter</name><description>Demo project for Spring Boot</description><properties><java.version>1.8</java.version></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-autoconfigure</artifactId></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency><dependency><groupId>com.hierynomus</groupId><artifactId>sshj</artifactId><version>0.26.0</version></dependency><dependency><groupId>org.bouncycastle</groupId><artifactId>bcprov-jdk15on</artifactId><version>1.60</version></dependency><dependency><groupId>com.fasterxml.uuid</groupId><artifactId>java-uuid-generator</artifactId><version>3.1.4</version></dependency><dependency><groupId>net.sf.expectit</groupId><artifactId>expectit-core</artifactId><version>0.9.0</version></dependency><dependency><groupId>org.apache.commons</groupId><artifactId>commons-pool2</artifactId><version>2.8.0</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><scope>test</scope></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><configuration><excludes><exclude><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></exclude></excludes></configuration></plugin></plugins></build></project>

具体的封装代码: 

package com.devops.ssh.autoconfigure;import com.devops.ssh.pool.SshClientPoolConfig;
import com.devops.ssh.pool.SshClientsPool;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;/*** @author Gary*/
@Configuration
@EnableConfigurationProperties(SshClientPoolProperties.class)
public class SshClientPoolAutoConfiguration {private final SshClientPoolProperties properties;public SshClientPoolAutoConfiguration(SshClientPoolProperties properties) {this.properties = properties;}@Bean@ConditionalOnMissingBean(SshClientsPool.class)SshClientsPool sshClientsPool() {return new SshClientsPool(sshClientPoolConfig());}SshClientPoolConfig sshClientPoolConfig() {SshClientPoolConfig poolConfig = new SshClientPoolConfig(properties.getMaxActive(),properties.getMaxIdle(),properties.getIdleTime(),properties.getMaxWait());if(properties.getSshj()!=null) {poolConfig.setServerCommandPromotRegex(properties.getSshj().getServerCommandPromotRegex());}if (properties.getSshClientImplClass()!=null) {try {poolConfig.setSshClientImplClass(Class.forName(properties.getSshClientImplClass()));} catch (ClassNotFoundException e) {e.printStackTrace();}}return poolConfig;}
}

package com.devops.ssh.autoconfigure;import org.springframework.boot.context.properties.ConfigurationProperties;@ConfigurationProperties("devops.ssh-client-pool")
public class SshClientPoolProperties {/*** Max number of "idle" connections in the pool. Use a negative value to indicate* an unlimited number of idle connections.*/private int maxIdle = 20;/*** */private int idleTime = 120*1000;/*** Max number of connections that can be allocated by the pool at a given time.* Use a negative value for no limit.*/private int maxActive = 20;/*** Maximum amount of time (in milliseconds) a connection allocation should block* before throwing an exception when the pool is exhausted. Use a negative value* to block indefinitely.*/private int maxWait = 120*1000;private String sshClientImplClass = "com.devops.ssh.SshClientSSHJ";private SshClientProperites sshj;public int getMaxIdle() {return maxIdle;}public void setMaxIdle(int maxIdle) {this.maxIdle = maxIdle;}public int getIdleTime() {return idleTime;}public void setIdleTime(int idleTime) {this.idleTime = idleTime;}public int getMaxActive() {return maxActive;}public void setMaxActive(int maxActive) {this.maxActive = maxActive;}public int getMaxWait() {return maxWait;}public void setMaxWait(int maxWait) {this.maxWait = maxWait;}public String getSshClientImplClass() {return sshClientImplClass;}public void setSshClientImplClass(String sshClientImplClass) {this.sshClientImplClass = sshClientImplClass;}public SshClientProperites getSshj() {return sshj;}public void setSshj(SshClientProperites sshj) {this.sshj = sshj;}public static class SshClientProperites{private String serverCommandPromotRegex;public String getServerCommandPromotRegex() {return serverCommandPromotRegex;}public void setServerCommandPromotRegex(String serverCommandPromotRegex) {this.serverCommandPromotRegex = serverCommandPromotRegex;}}}

package com.devops.ssh.exception;/*** Ssh auth failed* @author Gary**/
public class AuthException extends SshException{public AuthException(String message) {this(message, null);}public AuthException(String message, Throwable error) {super(message, error);}/*** */private static final long serialVersionUID = -3961786667342327L;}
package com.devops.ssh.exception;/*** The ssh connection is disconnected* @author Gary**/
public class LostConnectionException extends SshException{private static final long serialVersionUID = -3961870786667342727L;public LostConnectionException(String message) {this(message, null);}public LostConnectionException(String message, Throwable error) {super(message, error);}
}
package com.devops.ssh.exception;public class SshException extends Exception{/*** */private static final long serialVersionUID = 2052615275027564490L;public SshException(String message, Throwable error) {super(message);if(error != null) {initCause(error);}}public SshException(String message) {this(message, null);}}
package com.devops.ssh.exception;/*** Timeout Exception* @author Gary**/
public class TimeoutException extends SshException {public TimeoutException(String message) {this(message, null);}public TimeoutException(String message, Throwable error) {super(message, error);}/****/private static final long serialVersionUID = -39618386667342727L;}
package com.devops.ssh.pool;import com.devops.ssh.SshClient;
import com.devops.ssh.SshClientSSHJ;
import org.apache.commons.pool2.impl.GenericKeyedObjectPoolConfig;/**** The configuration of SshClientPool library* <p>SshClientPoolConfig is a subclass of GenericKeyedObjectPoolConfig to control the pool behavior* <p>Also, you can replace the build-in {@link SshClient} implementation by {@link SshClientPoolConfig#setSshClientImplClass(Class)} if you want** @author Gary*/
public class SshClientPoolConfig extends GenericKeyedObjectPoolConfig<SshClientWrapper>{private Class<?> sshClientImplClass;private String serverCommandPromotRegex;public SshClientPoolConfig() {super();}/*** quick way to create SshClientPoolConfig* set TestOnBorrow to true* set TestOnReturn to true* set TestWhileIdle to true* set JmxEnabled to false* @param maxActive maxTotalPerKey* @param maxIdle maxIdlePerKey* @param idleTime idle time* @param maxWaitTime maxWaitMillis*/public SshClientPoolConfig(int maxActive, int maxIdle, long idleTime,  long maxWaitTime){this.setMaxTotalPerKey(maxActive);this.setMaxIdlePerKey(maxIdle);this.setMaxWaitMillis(maxWaitTime);this.setBlockWhenExhausted(true);this.setMinEvictableIdleTimeMillis(idleTime);this.setTimeBetweenEvictionRunsMillis(idleTime);this.setTestOnBorrow(true);this.setTestOnReturn(true);this.setTestWhileIdle(true);this.setJmxEnabled(false);}public Class<?> getSshClientImplClass() {return sshClientImplClass;}/*** replace the build-in {@link SshClient} by {@link SshClientPoolConfig#setSshClientImplClass(Class)}* @param sshClientImplClass the implementation of {@link SshClient}*/public void setSshClientImplClass(Class<?> sshClientImplClass) {this.sshClientImplClass = sshClientImplClass;}/**** @return regex string used to match promot from server*/public String getServerCommandPromotRegex() {return serverCommandPromotRegex;}/*** see {@link SshClientSSHJ#setCommandPromotRegexStr(String)}* @param serverCommandPromotRegex regex string used to match promot from server*/public void setServerCommandPromotRegex(String serverCommandPromotRegex) {this.serverCommandPromotRegex = serverCommandPromotRegex;}}
package com.devops.ssh.pool;import com.devops.ssh.*;
import com.devops.ssh.exception.SshException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;import java.util.UUID;/*** A wrapper class of {@link SshClient} used by {@link SshClientsPool}** @author Gary**/
public class SshClientWrapper implements SshClientEventListener {private final static Logger logger = LoggerFactory.getLogger(SshClientWrapper.class);private String id;private SshClient client;SshClientEventListener listener;SshClientConfig config;public String getId() {return this.id;}public void setListener(SshClientEventListener listener) {this.listener = listener;}public SshClientConfig getConfig() {return this.config;}public SshClientWrapper(SshClientConfig config, SshClientPoolConfig poolConfig) {this.id = UUID.randomUUID().toString();this.config = config;this.client = SshClientFactory.newInstance(config, poolConfig);}public SshClientWrapper setEventListener(SshClientEventListener listener) {this.listener = listener;this.client.setEventListener(this);return this;}public SshClientWrapper connect(int timeoutInSeconds) throws SshException {client.connect(timeoutInSeconds);return this;}public SshClientWrapper auth() throws SshException{if(null!=this.config.getPassword() && this.config.getPassword().length()>0) {client.authPassword();}else if(null!=this.config.getPrivateKeyPath() && this.config.getPrivateKeyPath().length()>0) {client.authPublickey();}else {client.authPublickey();}return this;}public SshClientWrapper startSession() throws SshException{client.startSession(true);return this;}public SshResponse executeCommand(String command, int timeoutInSeconds){SshResponse response = client.executeCommand(command, timeoutInSeconds);return response;}public void disconnect() {client.disconnect();}@Overridepublic boolean equals(Object obj) {if(obj instanceof SshClientWrapper){return id.equals(((SshClientWrapper)obj).getId());}return false;}@Overridepublic int hashCode(){return id.hashCode();}public SshClientState getState() {return client.getState();}@Overridepublic String toString() {return "["+this.id+"|"+this.config.getHost()+"|"+this.config.getPort()+"|"+this.getState()+"]";}@Overridepublic void didExecuteCommand(Object client) {this.listener.didExecuteCommand(this);}@Overridepublic void didDisConnected(Object client) {this.listener.didDisConnected(this);}@Overridepublic void didConnected(Object client) {this.listener.didConnected(this);}}
package com.devops.ssh;import com.devops.ssh.exception.SshException;/*** Ssh Client used to connect to server instance and execute command. The build-in implementation is {@link SshClientSSHJ}<p>** Client can be used in chain mode, {@link SshClient}.{@link #init(SshClientConfig)}.{@link #connect(int)}.{@link #authPassword()}.{@link #startSession(boolean)}.{@link #executeCommand(String, int)}<p>** At last, close the client with {@link #disconnect()}** <p>Set an {@link SshClientEventListener} with {@link #setEventListener(SshClientEventListener)} to be notified when its event occurs* <p>* @author Gary**/
public interface SshClient {/*** pass the {@link SshClientConfig} to client* @param config the information used to connect to server* @return SshClient itself*/public SshClient init(SshClientConfig config);/*** connect to server, and timeout if longer than {@code timeoutInSeconds}* @param timeoutInSeconds timeout in seconds* @return SshClient itself* @throws SshException if server is unreachable, usually the host and port is incorrect*/public SshClient connect(int timeoutInSeconds) throws SshException;/*** auth with password* @return SshClient itself* @throws SshException if username or password is incorrect*/public SshClient authPassword() throws SshException;/*** auth with key* @return SshClient itself* @throws SshException if username or public key is incorrect*/public SshClient authPublickey() throws SshException;/*** start session* @param shellMode <tt>true</tt>: communicate with server interactively in session, just like command line* <p><tt>false</tt>: only execute command once in session* @return SshClient itself* @throws SshException when start session failed**/public SshClient startSession(boolean shellMode) throws SshException;/**** @param command execute the {@code command} on server instance, and timeout if longer than {@code timeoutInSeconds}.* @param timeoutInSeconds timeout in seconds* @return SshResponse**/public SshResponse executeCommand(String command, int timeoutInSeconds);/*** set the listener on SshClient* @param listener notify listener when events occur in SshClient* @return SshClient itself*/public SshClient setEventListener(SshClientEventListener listener);/*** disconnect from server*/public void disconnect();/*** state of SshClient** @return SshClientState the state of ssh client* <p><tt>inited</tt> before {@link #startSession(boolean)} success* <p><tt>connected</tt> after {@link #startSession(boolean)} success* <p><tt>disconnected</tt> after {@link #disconnect()}, or any connection problem occurs*/public SshClientState getState();}
package com.devops.ssh;/**** Configuration used by {@link SshClient} to connect to remote server instance** @author Gary**/
public class SshClientConfig {private String host;private int port;private String username;private String password;private String privateKeyPath;private String id;/**** @return host address*/public String getHost() {return host;}/*** @param host host address, usually the ip address of remote server*/public void setHost(String host) {this.host = host;}/**** @return ssh port of the remote server*/public int getPort() {return port;}/*** @param port ssh port of the remote server*/public void setPort(int port) {this.port = port;}/**** @return ssh username of the remote server*/public String getUsername() {return username;}/**** @param username ssh username of the remote server*/public void setUsername(String username) {this.username = username;}/**** @return ssh password of the remote server*/public String getPassword() {return password;}/**** @param password ssh password of the remote server*/public void setPassword(String password) {this.password = password;}/*** @return ssh local key file path of the remote server*/public String getPrivateKeyPath() {return privateKeyPath;}/*** @param privateKeyPath local key file path of the remote server*/public void setPrivateKeyPath(String privateKeyPath) {this.privateKeyPath = privateKeyPath;}/**** @return id of the config*/public String getId() {return id;}/**** @param host           server host address* @param port           server ssh port* @param username       server ssh username* @param password       server ssh password* @param privateKeyPath local security key used to connect to server*/public SshClientConfig(String host, int port, String username, String password, String privateKeyPath) {this.id = host + port + username;if (null != password && password.length() > 0) {this.id += password;}if (privateKeyPath != null) {this.id += privateKeyPath;}this.host = host;this.port = port;this.username = username;this.password = password;this.privateKeyPath = privateKeyPath;}public SshClientConfig() {}@Overridepublic boolean equals(Object obj) {if (obj instanceof SshClientConfig) {return id.equals(((SshClientConfig) obj).getId());}return false;}@Overridepublic int hashCode() {return id.hashCode();}@Overridepublic String toString() {return this.id;}
}
package com.devops.ssh;/**** Set listener to a SshClient by {@link SshClient#setEventListener(SshClientEventListener)}* @author Gary**/
public interface SshClientEventListener {/*** after SshClient finished executing command* @param client the ssh client*/public void didExecuteCommand(Object client);/*** after SshClient disconnnect from the remote server* @param client the ssh client*/public void didDisConnected(Object client);/*** after SshClient start the ssh session* @param client the ssh client*/public void didConnected(Object client);
}
package com.devops.ssh;import com.devops.ssh.pool.SshClientPoolConfig;/**** Factory of {@link SshClient} implementation* <p> Create a new instance of {@link SshClientSSHJ} with {@link #newInstance(SshClientConfig)}* <p> Create a custom implementation of {@link SshClient} with {@link #newInstance(SshClientConfig, SshClientPoolConfig)}** @author Gary**/
public class SshClientFactory {/*** Create a new instance of {@link SshClientSSHJ}* @param config ssh connection configuration of the remote server* @return SshClient in inited state*/public static SshClient newInstance(SshClientConfig config){return newInstance(config, null);}/*** Create a custom implementation of {@link SshClient}* @param config ssh connection configuration of the remote server* @param poolConfig customized configuration* @return SshClient in inited state* @throws RuntimeException if SshClientImplClass in {@code poolConfig} is invalid*/public static SshClient newInstance(SshClientConfig config, SshClientPoolConfig poolConfig){try {SshClient client = null;if (poolConfig==null || poolConfig.getSshClientImplClass()==null){client = new SshClientSSHJ();}else {client = (SshClient)poolConfig.getSshClientImplClass().newInstance();}client.init(config);if(client instanceof SshClientSSHJ && poolConfig!=null && poolConfig.getServerCommandPromotRegex()!=null) {((SshClientSSHJ)client).setCommandPromotRegexStr(poolConfig.getServerCommandPromotRegex());}return client;} catch (InstantiationException e) {throw new RuntimeException("new instance failed", e);} catch (IllegalAccessException e) {throw new RuntimeException("new instance failed", e);}}}
package com.devops.ssh;import com.devops.ssh.exception.AuthException;
import com.devops.ssh.exception.LostConnectionException;
import com.devops.ssh.exception.SshException;
import com.devops.ssh.exception.TimeoutException;
import com.devops.ssh.pool.SshClientPoolConfig;
import net.schmizz.sshj.DefaultConfig;
import net.schmizz.sshj.SSHClient;
import net.schmizz.sshj.connection.channel.direct.Session;
import net.schmizz.sshj.connection.channel.direct.Session.Command;
import net.schmizz.sshj.connection.channel.direct.Session.Shell;
import net.schmizz.sshj.transport.TransportException;
import net.schmizz.sshj.transport.verification.PromiscuousVerifier;
import net.schmizz.sshj.userauth.keyprovider.KeyProvider;
import net.sf.expectit.Expect;
import net.sf.expectit.ExpectBuilder;
import net.sf.expectit.ExpectIOException;
import net.sf.expectit.Result;
import net.sf.expectit.matcher.Matcher;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.SocketException;
import java.nio.channels.ClosedByInterruptException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;import static net.sf.expectit.filter.Filters.removeColors;
import static net.sf.expectit.filter.Filters.removeNonPrintable;
import static net.sf.expectit.matcher.Matchers.contains;
import static net.sf.expectit.matcher.Matchers.regexp;/**** build-in {@link SshClient} implementation  with <a href="https://github.com/hierynomus/sshj">hierynomus/SshJ</a>** <p>Trouble and shooting:* <p>Problem: {@link #authPublickey()} throw exceptions contains "net.schmizz.sshj.common.Buffer$BufferException:Bad item length"* <p>Solution: may caused by key file format issue,use ssh-keygen on a remote Linux server to generate the key*** @author Gary**/
public class SshClientSSHJ implements SshClient {private final static Logger logger = LoggerFactory.getLogger(SshClientSSHJ.class);private SshClientConfig clientConfig;private SSHClient client;private Expect expect = null;private Session session = null;private Shell shell = null;private boolean shellMode = false;private SshClientState state = SshClientState.inited;private SshClientEventListener eventListener;public String commandPromotRegexStr = "[\\[]?.+@.+~[\\]]?[#\\$] *";public Matcher<Result> commandPromotRegex = regexp(commandPromotRegexStr);// initialize DefaultConfig will consume resources, so we should cache itprivate static DefaultConfig defaultConfig = null;public static DefaultConfig getDefaultConfig() {if(defaultConfig==null) {defaultConfig = new DefaultConfig();}return defaultConfig;}/*** used in shell mode, once it start session with server, the server will return promot to client* <p>the promot looks like [centos@ip-172-31-31-82 ~]$* <p>if the build-in one does not fit, you can change it by {@link SshClientPoolConfig#setServerCommandPromotRegex(String)}* @param promot used to match promot from server*/public void setCommandPromotRegexStr(String promot) {this.commandPromotRegexStr = promot;this.commandPromotRegex = regexp(this.commandPromotRegexStr);}@Overridepublic SshClient init(SshClientConfig config) {this.clientConfig = config;return this;}private void validate() throws SshException {if(this.clientConfig == null) {throw new SshException("missing client config");}}@Overridepublic SshClient connect(int timeoutInSeconds) throws SshException{this.validate();if (timeoutInSeconds <= 0) {timeoutInSeconds = Integer.MAX_VALUE;} else {timeoutInSeconds = timeoutInSeconds * 1000;}return this.connect(timeoutInSeconds, false);}private SshClient connect(int timeoutInSeconds, boolean retry) throws SshException{logger.debug("connecting to " + this.clientConfig.getHost() + " port:" + this.clientConfig.getPort() + " timeout in:"+ (timeoutInSeconds / 1000) + " s");client = new SSHClient(getDefaultConfig());try {client.setConnectTimeout(timeoutInSeconds);client.addHostKeyVerifier(new PromiscuousVerifier());// client.loadKnownHosts();client.connect(this.clientConfig.getHost().trim(), this.clientConfig.getPort());logger.debug("connected to " + this.clientConfig.getHost().trim() + " port:" + this.clientConfig.getPort());} catch (TransportException e) {if(!retry) {logger.error("sshj get exception when connect and will retry one more time ", e);try {Thread.sleep(1000);} catch (InterruptedException e1) {}return this.connect(timeoutInSeconds, true);}else {String errorMessage ="connect to " + this.clientConfig.getHost().trim() + " failed";logger.error(errorMessage, e);throw new SshException(errorMessage, e);}} catch (Exception e) {String errorMessage ="connect to " + this.clientConfig.getHost().trim() + " failed";logger.error(errorMessage, e);throw new SshException(errorMessage, e);}return this;}@Overridepublic SshClient setEventListener(SshClientEventListener listener) {this.eventListener = listener;return this;}@Overridepublic SshClient authPassword() throws SshException {try {logger.debug("auth with password");client.authPassword(this.clientConfig.getUsername(), this.clientConfig.getPassword());} catch (Exception e) {String errorMessage = "ssh auth " + this.clientConfig.getHost() + " fail";logger.error(errorMessage, e);throw new AuthException(errorMessage, e);}return this;}@Overridepublic SshClient authPublickey() throws SshException {try {logger.debug("auth with key:"+this.clientConfig.getUsername()+","+this.clientConfig.getPrivateKeyPath());if (this.clientConfig.getPrivateKeyPath() != null) {KeyProvider keys = client.loadKeys(this.clientConfig.getPrivateKeyPath());client.authPublickey(this.clientConfig.getUsername(), keys);} else {client.authPublickey(this.clientConfig.getUsername());}} catch (Exception e) {String errorMessage = "ssh auth " + this.clientConfig.getHost() + " fail";logger.error(errorMessage, e);throw new AuthException(errorMessage, e);}return this;}@Overridepublic SshClient startSession(boolean shellMode) {logger.info("start session " + (shellMode ? " in shellMode" : ""));try {session = client.startSession();this.shellMode = shellMode;if (shellMode) {session.allocateDefaultPTY();shell = session.startShell();shell.changeWindowDimensions(1024, 1024, 20, 20);this.renewExpect(60);expect.expect(commandPromotRegex);}this.state = SshClientState.connected;try {if(this.eventListener!=null) {this.eventListener.didConnected(this);}} catch (Exception e) {}} catch (Exception e) {if(e instanceof ExpectIOException) {ExpectIOException ioException = (ExpectIOException)e;logger.error("start session fail with server input:"+ioException.getInputBuffer().replaceAll("[\\\n\\\r]", ""), e);}else {logger.error("start session fail", e);}this.disconnect();throw new RuntimeException("start session fail." + e.getMessage());} finally {// close expecttry {if (expect != null) {expect.close();}} catch (IOException e) {logger.error("close IO error", e);}expect = null;}return this;}@Overridepublic SshResponse executeCommand(String command, int timeoutInSeconds) {if (this.shellMode) {return this.sendCommand(command, timeoutInSeconds);} else {return this.executeCommand_(command, timeoutInSeconds);}}private SshResponse executeCommand_(String command, int timeoutInSeconds) {logger.info("execute command: " + command);SshResponse response = new SshResponse();try {Command cmd = session.exec(command);if (timeoutInSeconds < 0) {cmd.join(Long.MAX_VALUE, TimeUnit.SECONDS);} else {cmd.join(timeoutInSeconds, TimeUnit.SECONDS);}BufferedReader reader = new BufferedReader(new InputStreamReader(cmd.getInputStream(), "UTF-8"));BufferedReader error_reader = new BufferedReader(new InputStreamReader(cmd.getErrorStream(), "UTF-8"));List<String> outputLines = new ArrayList<>();logger.debug("finish executing command on " + this.clientConfig.getHost() + ", console:");String outputLine;while ((outputLine = error_reader.readLine()) != null) {logger.debug(outputLine);outputLines.add(outputLine);}while ((outputLine = reader.readLine()) != null) {logger.debug(outputLine);outputLines.add(outputLine);}response.setStdout(outputLines);logger.info("execute ssh command on " + this.clientConfig.getHost() + " completed, with exit status:" + cmd.getExitStatus());response.setCode(cmd.getExitStatus());} catch (Exception e) {if (e.getCause() instanceof InterruptedException || e.getCause() instanceof java.util.concurrent.TimeoutException) {logger.error("execute ssh on " + this.clientConfig.getHost() + " timeout");response.setException(new TimeoutException("execute ssh command timeout"));} else {logger.error("execute ssh on " + this.clientConfig.getHost() + ", command error", e);response.setException(new SshException("execute ssh command error "+e.getMessage()));}}finally {try {if(this.eventListener!=null) {this.eventListener.didExecuteCommand(this);}} catch (Exception e) {}}return response;}private SshResponse sendCommand(String command, int timeoutInSeconds) {SshResponse response = new SshResponse();if (this.state != SshClientState.connected) {response.setException(new LostConnectionException("client not connected"));response.setCode(0);return response;}try {this.renewExpect(timeoutInSeconds);// start expectlogger.info(this + " execute command : " + command);expect.send(command);logger.debug(this + " command sent ");if (!command.endsWith("\n")) {expect.send("\n");logger.debug(this + " command \\n sent ");}Result result2 = expect.expect(contains(command));Result result = expect.expect(commandPromotRegex);logger.debug("command execute success with raw output");logger.debug("------------------------------------------");String[] inputArray = result.getInput().split("\\r\\n");List<String> stout = new ArrayList<String>();if(inputArray.length>0) {for(int i=0;i<inputArray.length;i++) {logger.debug(inputArray[i]);if(i==inputArray.length-1 && inputArray[i].matches(commandPromotRegexStr)) {break;}stout.add(inputArray[i]);}}logger.debug("------------------------------------------");response.setStdout(stout);response.setCode(0);logger.info("execute ssh command on " + this.clientConfig.getHost() + " completed, with code:" + 0);} catch (Exception e) {response.setCode(1);response.setException(new SshException(e.getMessage()));logger.error("execute command fail", e);if(e instanceof ArrayIndexOutOfBoundsException) {// server may be shutdownresponse.setException(new LostConnectionException("lost connection"));this.disconnect();} else if (e instanceof ClosedByInterruptException) {response.setException(new TimeoutException("execute command timeout"));this.sendCtrlCCommand();}else if (e.getCause() instanceof SocketException) {// the socket may be closedresponse.setException(new LostConnectionException("lost connection"));this.disconnect();} else if (e.getMessage().contains("timeout")) {response.setException(new TimeoutException("execute command timeout"));this.sendCtrlCCommand();}else {this.sendCtrlCCommand();}} finally {// close expecttry {if (expect != null) {expect.close();}} catch (IOException e) {logger.error("close IO error", e);}expect = null;try {if(this.eventListener!=null) {this.eventListener.didExecuteCommand(this);}} catch (Exception e) {}}return response;}private void renewExpect(int timeoutInSeconds) throws IOException {if (expect!=null) {try {expect.close();}catch(Exception e) {e.printStackTrace();}}expect = new ExpectBuilder().withOutput(shell.getOutputStream()).withInputs(shell.getInputStream(), shell.getErrorStream()).withInputFilters(removeColors(), removeNonPrintable()).withExceptionOnFailure().withTimeout(timeoutInSeconds, TimeUnit.SECONDS).build();}private void sendCtrlCCommand() {try {logger.debug("send ctr-c command ... ");expect.send("\03");expect.expect(commandPromotRegex);logger.debug("send ctr-c command success ");} catch (IOException e1) {logger.error("send ctrl+c command fail", e1);}}@Overridepublic void disconnect() {if(this.state== SshClientState.disconnected) {return;}this.state = SshClientState.disconnected;try {if (shell != null) {shell.close();}} catch (IOException e) {logger.error("close ssh shell error", e);}try {if (session != null) {session.close();}} catch (IOException e) {logger.error("close sesion error", e);}try {if (client != null) {client.disconnect();client.close();}} catch (IOException e) {logger.error("close ssh conenction error", e);}logger.debug("ssh disconnect");try {if(this.eventListener!=null) {this.eventListener.didDisConnected(this);}} catch (Exception e) {}}@Overridepublic SshClientState getState() {return this.state;}
}
package com.devops.ssh;/**** state of SshClient, See {@link SshClient#getState()} for more information** @author Gary**/
public enum SshClientState {inited,connected,disconnected
}
package com.devops.ssh;import java.util.ArrayList;
import java.util.List;/**** Response return from {@link SshClient#executeCommand(String, int)}** @author Gary**/
public class SshResponse {private int code;private Exception exception;private List<String> stdout = new ArrayList<String>();/*** @return 0*/public int getCode() {return code;}public void setCode(int code) {this.code = code;}/**** @return the exception in {@link SshClient#executeCommand(String, int)}*/public Exception getException() {return exception;}public void setException(Exception exception) {this.exception = exception;}/**** @return the output from remote server after send command*/public List<String> getStdout() {return stdout;}public void setStdout(List<String> stdout) {this.stdout = stdout;}}

 运行测试Linux命令

echo 'yes'

 运行测试 shell 脚本

http://www.hrbkazy.com/news/16300.html

相关文章:

  • 做网站 参考文献东莞百度搜索优化
  • 功能性的网站归档系统深度优化
  • 毕业论文网站提高基层治理效能
  • 四川网站建设价格chatgpt 网站
  • 做网站步骤大连谷歌seo
  • 石家庄手机网站制作多少钱百度云网盘官网
  • 高端 网站硬件工程师培训机构哪家好
  • 网站怎么做能快速有排名昆明长尾词seo怎么优化
  • 网站开始是怎么做的seo的基础是什么
  • 如何做网站网页费用常德网站建设制作
  • 家具设计理念常用的seo工具
  • 想建一个自己的网站站长平台工具
  • 通化好的网站建设的公司百度投诉中心24人工客服
  • 绍兴网站关键词优化seo排名软件哪个好用
  • 网站商城定制网站建设百度搜索广告怎么收费
  • 色盲测试商丘关键词优化推广
  • 透视图在什么网站上可以做个人博客网页设计html
  • 怎么做网站做站点小程序定制
  • 西宁做政府网站的公司wix网站制作
  • 邯郸企业网站建设公司百度竞价排名背后的伦理问题
  • 搞笑网站建设目的和意义网络销售真恶心
  • 装饰公司在哪个网站上接活网络营销岗位
  • 自己做的网站怎么弄成app如何优化网络
  • 网站运营专员是干嘛的seo免费视频教程
  • 做准的算命网站个人网站网址
  • 肇庆做网站seo技术教程博客
  • 自己怎么做网上注册免费的网站做网站哪家好
  • java jsp做网站外贸建站与推广
  • 提升学历选择哪种方式好济南seo关键词优化方案
  • 企业网站怎么做毕业设计企业网站的功能