// 服務(wù)器連接配置示例
public class ServerConfig {
    private String host;
    private int port;
    private String username;
    private String password;
    // 構(gòu)造方法、getter和setter省略
}
// 模擬10臺(tái)服務(wù)器配置
List<ServerConfig> servers = Arrays.asList(
    new ServerConfig("192.168.1.101", 22, "admin", "password1"),
    new ServerConfig("192.168.1.102", 22, "admin", "password2"),
    // ...更多服務(wù)器配置
    new ServerConfig("192.168.1.110", 22, "admin", "password10")
);

// 獲取所有會(huì)話對(duì)象
var sessions = XShell.Sessions;
for (var i = 0; i < sessions.Count; i++) {
    var sess = sessions.Item(i);
    if (sess.Connected) {
        sess.Send("hostname && date");
        // 等待1秒讓命令執(zhí)行完成
        XSleep(1000);
        // 獲取輸出（需配合日志記錄）
    }
}

// 對(duì)應(yīng)的Java模擬代碼 - 批量執(zhí)行命令
public class XshellScriptSimulator {
    public void executeCommandOnAllServers(List<ServerConfig> servers, String command) {
        List<Future<CommandResult>> futures = new ArrayList<>();
        ExecutorService executor = Executors.newFixedThreadPool(5);
        for (ServerConfig server : servers) {
            futures.add(executor.submit(() -> {
                // 模擬SSH連接和執(zhí)行命令
                Thread.sleep(500); // 模擬網(wǎng)絡(luò)延遲
                System.out.println("在服務(wù)器 " + server.getHost() + " 執(zhí)行: " + command);
                return new CommandResult(server.getHost(), 0, "執(zhí)行成功");
            }));
        }
        // 等待所有任務(wù)完成
        for (Future<CommandResult> future : futures) {
            try {
                CommandResult result = future.get();
                System.out.println("服務(wù)器 " + result.getHost() + " 結(jié)果: " + result.getOutput());
            } catch (Exception e) {
                System.err.println("執(zhí)行異常: " + e.getMessage());
            }
        }
        executor.shutdown();
    }
}

# inventory.yml 主機(jī)清單文件
web_servers:
  hosts:
    web1:
      ansible_host: 192.168.1.101
      ansible_user: admin
    web2:
      ansible_host: 192.168.1.102
      ansible_user: admin
    # ...更多服務(wù)器
db_servers:
  hosts:
    db1:
      ansible_host: 192.168.1.201
      ansible_user: admin

[web_servers]
192.168.1.10
192.168.1.11
[db_servers]
192.168.1.20 ansible_user=admin

ansible all -i inventory.yml -m command -a "df -h"

// Java中調(diào)用Ansible的示例
public class AnsibleExecutor {
    public void runAnsibleCommand(String inventoryPath, String command) {
        try {
            ProcessBuilder pb = new ProcessBuilder(
                "ansible", "all", "-i", inventoryPath, 
                "-m", "command", "-a", command
            );
            Process process = pb.start();
            BufferedReader reader = new BufferedReader(
                new InputStreamReader(process.getInputStream())
            );
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            int exitCode = process.waitFor();
            System.out.println("Ansible執(zhí)行完成，退出碼: " + exitCode);
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

# 創(chuàng)建主機(jī)文件
echo "192.168.1.101
192.168.1.102
...
192.168.1.110" > hosts.txt
# 執(zhí)行并行命令
pssh -h hosts.txt -l admin -A -i "uptime"

root@192.168.1.10:22
admin@192.168.1.11

pssh -h hosts.txt -i "uptime"

// Java集成PSSH功能
public class PsshIntegration {
    public void executeParallelCommand(List<String> hosts, String username, String command) {
        // 生成主機(jī)文件
        Path hostsFile = createHostsFile(hosts);
        try {
            Process process = Runtime.getRuntime().exec(
                "pssh -h " + hostsFile.toString() + 
                " -l " + username + 
                " -i \"" + command + "\""
            );
            // 處理輸出
            processOutput(process);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    private Path createHostsFile(List<String> hosts) {
        // 創(chuàng)建臨時(shí)主機(jī)文件
        // 實(shí)現(xiàn)省略
        return null;
    }
}

// 使用JSch庫(kù)實(shí)現(xiàn)SSH批量執(zhí)行
public class BulkSshExecutor {
    private final List<ServerConfig> servers;
    private final int timeout;
    public BulkSshExecutor(List<ServerConfig> servers, int timeout) {
        this.servers = servers;
        this.timeout = timeout;
    }
    public Map<String, CommandResult> executeCommand(String command) {
        Map<String, CommandResult> results = new ConcurrentHashMap<>();
        ExecutorService executor = Executors.newFixedThreadPool(10);
        for (ServerConfig server : servers) {
            executor.submit(() -> {
                try {
                    JSch jsch = new JSch();
                    Session session = jsch.getSession(
                        server.getUsername(), 
                        server.getHost(), 
                        server.getPort()
                    );
                    session.setPassword(server.getPassword());
                    session.setConfig("StrictHostKeyChecking", "no");
                    session.connect(timeout);
                    ChannelExec channel = (ChannelExec) session.openChannel("exec");
                    channel.setCommand(command);
                    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
                    ByteArrayOutputStream errorStream = new ByteArrayOutputStream();
                    channel.setOutputStream(outputStream);
                    channel.setErrStream(errorStream);
                    channel.connect();
                    // 等待命令執(zhí)行完成
                    while (!channel.isClosed()) {
                        Thread.sleep(100);
                    }
                    int exitStatus = channel.getExitStatus();
                    session.disconnect();
                    results.put(server.getHost(), new CommandResult(
                        server.getHost(), 
                        exitStatus, 
                        exitStatus == 0 ? outputStream.toString() : errorStream.toString()
                    ));
                } catch (Exception e) {
                    results.put(server.getHost(), new CommandResult(
                        server.getHost(), 
                        -1, 
                        "執(zhí)行異常: " + e.getMessage()
                    ));
                }
            });
        }
        executor.shutdown();
        try {
            executor.awaitTermination(5, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return results;
    }
}

import paramiko
from concurrent.futures import ThreadPoolExecutor
def exec_command(host, user, key_file, command):
    client = paramiko.SSHClient()
    client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    client.connect(host, username=user, key_filename=key_file)
    stdin, stdout, stderr = client.exec_command(command)
    return host, stdout.read().decode(), stderr.read().decode()
hosts = ["10.0.0.1", "10.0.0.2"]
with ThreadPoolExecutor(max_workers=10) as executor:
    futures = [executor.submit(exec_command, h, "root", "/home/key", "df -h") for h in hosts]
    for f in futures:
        print(f.result())

// 支持異步回調(diào)的批量執(zhí)行器
public class AdvancedBulkExecutor {
    private final ExecutorService callbackExecutor = Executors.newCachedThreadPool();
    public void executeWithCallback(List<ServerConfig> servers, String command, 
                                   ResultCallback callback) {
        BulkSshExecutor executor = new BulkSshExecutor(servers, 30000);
        Map<String, CommandResult> results = executor.executeCommand(command);
        // 異步處理回調(diào)
        callbackExecutor.submit(() -> {
            for (Map.Entry<String, CommandResult> entry : results.entrySet()) {
                if (entry.getValue().getExitCode() == 0) {
                    callback.onSuccess(entry.getKey(), entry.getValue().getOutput());
                } else {
                    callback.onFailure(entry.getKey(), entry.getValue().getOutput());
                }
            }
            callback.onComplete(results);
        });
    }
    public interface ResultCallback {
        void onSuccess(String host, String output);
        void onFailure(String host, String error);
        void onComplete(Map<String, CommandResult> allResults);
    }
}

// 安全的連接配置示例
public class SecureSshConnector {
    public Session createSecureSession(ServerConfig server) throws JSchException {
        JSch jsch = new JSch();
        // 使用密鑰認(rèn)證
        jsch.addIdentity(server.getPrivateKeyPath());
        Session session = jsch.getSession(server.getUsername(), server.getHost(), server.getPort());
        // 安全配置
        Properties config = new Properties();
        config.put("StrictHostKeyChecking", "yes");
        config.put("PreferredAuthentications", "publickey");
        session.setConfig(config);
        session.connect();
        return session;
    }
}

// 帶連接池的SSH執(zhí)行器
public class SshConnectionPool {
    private final Map<String, Session> sessionPool = new ConcurrentHashMap<>();
    private final int maxSessionsPerHost;
    public SshConnectionPool(int maxSessionsPerHost) {
        this.maxSessionsPerHost = maxSessionsPerHost;
    }
    public synchronized Session getSession(ServerConfig server) throws JSchException {
        String key = server.getHost() + ":" + server.getPort();
        Session session = sessionPool.get(key);
        if (session == null || !session.isConnected()) {
            JSch jsch = new JSch();
            session = jsch.getSession(server.getUsername(), server.getHost(), server.getPort());
            session.setPassword(server.getPassword());
            session.connect();
            sessionPool.put(key, session);
        }
        return session;
    }
}

// 增強(qiáng)的批量執(zhí)行器 with 日志記錄
public class LoggingBulkExecutor {
    private static final Logger logger = LoggerFactory.getLogger(LoggingBulkExecutor.class);
    public Map<String, CommandResult> executeWithLogging(List<ServerConfig> servers, String command) {
        Map<String, CommandResult> results = new HashMap<>();
        for (ServerConfig server : servers) {
            try {
                logger.info("開始在服務(wù)器 {} 執(zhí)行命令: {}", server.getHost(), command);
                CommandResult result = executeSingleCommand(server, command);
                results.put(server.getHost(), result);
                if (result.getExitCode() == 0) {
                    logger.info("服務(wù)器 {} 執(zhí)行成功: {}", server.getHost(), result.getOutput());
                } else {
                    logger.warn("服務(wù)器 {} 執(zhí)行失敗，退出碼: {}", server.getHost(), result.getExitCode());
                }
            } catch (Exception e) {
                logger.error("服務(wù)器 {} 執(zhí)行異常: {}", server.getHost(), e.getMessage());
                results.put(server.getHost(), new CommandResult(server.getHost(), -1, e.getMessage()));
            }
        }
        return results;
    }
}