Invio di comandi al server tramite il canale shell JSch

Non riesco a capire come posso inviare comandi tramite il canale di shell JSch.

Lo faccio, ma non funziona:

JSch shell = new JSch(); String command = "cd home/s/src"; Session session = shell.getSession(username, host, port); MyUserInfo ui = new MyUserInfo(); ui.setPassword(password); session.setUserInfo(ui); session.connect(); channel = session.openChannel("shell"); fromServer = new BufferedReader(new InputStreamReader(channel.getInputStream())); toServer = channel.getOutputStream(); channel.connect(); toServer.write((command + "\r\n").getBytes()); toServer.flush(); 

e poi ho letto input come questo:

 StringBuilder builder = new StringBuilder(); int count = 0; String line = ""; while(line != null) { line = fromServer.readLine(); builder.append(line).append("\n"); if (line.endsWith(".") || line.endsWith(">")){ break; } } String result = builder.toString(); ConsoleOut.println(result); 

Se si blocca su readLine() che significa che il tuo “while” non finisce mai (potrebbe essere improbabile considerando il tuo codice), oppure readLine() sta aspettando la sua origine, vale a dire il blocco di IOstream causa thread available()!=true .

Non riesco a risolvere il tuo codice senza visualizzare le tue informazioni di debug. Ma come consiglio, hai provato PipedIntputStream ? L’idea è di redirect l’input della tua console all’output “tuo” in modo da poterlo “scrivere”. Per implementare questo, è necessario inizializzare l’ingresso / l’uscita.

 InputStream in = new PipedInputStream(); PipedOutputStream pin = new PipedOutputStream((PipedInputStream) in); /**...*/ channel.setInputStream(in); channel.connect(); /** ...*/ pin.write(myScript.getBytes()); 

Lo stesso vale per la tua domanda, come leggere l’output della console.

 PipedInputStream pout = new PipedInputStream((PipedOutputStream) out); /** * ... */ BufferedReader consoleOutput = new BufferedReader(new InputStreamReader(pout)); consoleOutput.readLine(); 

E ancora, se non sei sicuro di quante righe leggere e quindi vuoi usare “while”, assicurati di fare qualcosa dentro per evitare che 1) busy-waiting 2) termini-condizioni. Esempio:

 while(!end) { consoleOutput.mark(32); if (consoleOutput.read()==0x03) end = true;//End of Text else { consoleOutput.reset(); consoleOutput.readLine(); end = false; } } 

Prova questo:

 JSch jsch = new JSch(); try { Session session = jsch.getSession("root", "192.168.0.1", 22); java.util.Properties config = new java.util.Properties(); config.put("StrictHostKeyChecking", "no"); session.setConfig(config); session.connect(); String command = "lsof -i :80"; Channel channel = session.openChannel("exec"); ((ChannelExec) channel).setCommand(command); channel.setInputStream(null); ((ChannelExec) channel).setErrStream(System.err); InputStream in = channel.getInputStream(); channel.connect(); byte[] tmp = new byte[1024]; while (true) { while (in.available() > 0) { int i = in.read(tmp, 0, 1024); if (i < 0) break; System.out.print(new String(tmp, 0, i)); } if (channel.isClosed()) { System.out.println("exit-status: " + channel.getExitStatus()); break; } try { Thread.sleep(1000); } catch (Exception ee) { } } channel.disconnect(); session.disconnect(); } catch (Exception e) { System.out.println(e.getMessage()); } 
 private void executeRemoteCommandAsSudo(String sudoAs, String password, String command, int delayInSeconds) { logger.info("executeRemoteCommandAsSudo started...."); logger.info("sudoAs=" + sudoAs); logger.info("command=" + command); logger.info("delayInSeconds=" + delayInSeconds); Session session = null; Channel channel = null; try { session = getSession(); channel = session.openChannel("exec"); String sudoCommand = "sudo su - " + sudoAs; ((ChannelExec) channel).setCommand(sudoCommand); ((ChannelExec) channel).setPty(true); channel.connect(); InputStream inputStream = channel.getInputStream(); OutputStream out = channel.getOutputStream(); ((ChannelExec) channel).setErrStream(System.err); out.write((password + "\n").getBytes()); out.flush(); Thread.sleep(1000); out.write((command + "\n").getBytes()); out.flush(); Thread.sleep(1000 * delayInSeconds); out.write(("logout" + "\n").getBytes()); out.flush(); Thread.sleep(1000); logInfo(channel, inputStream); out.write(("exit" + "\n").getBytes()); out.flush(); out.close(); Thread.sleep(1000); } catch (Exception ex) { logger.error(ex.getMessage()); } finally { session.disconnect(); channel.disconnect(); } logger.info("executeRemoteCommandAsSudo completed...."); } private void logInfo(Channel channel, InputStream in) { try { byte[] tmp = new byte[1024]; while (true) { while (in.available() > 0) { int i = in.read(tmp, 0, 1024); if (i < 0) break; logger.info(new String(tmp, 0, i)); } if (channel.isClosed()) { logger.info("exit-status: " + channel.getExitStatus()); break; } } } catch (Exception ex) { logger.error(ex); } } private Session getSession() throws JSchException { JSch jsch = new JSch(); logger.info("ftpUser=" + ftpUser); logger.info("ftpHost=" + ftpHost); Session session = jsch.getSession(ftpUser, ftpHost, 22); session.setPassword(ftpPassword); java.util.Properties config = new java.util.Properties(); config.put("StrictHostKeyChecking", "no"); session.setConfig(config); session.connect(); return session; } 

Di seguito è stato un codice scritto rapidamente per il mio incarico. Non è un programma ben fatto. Ma serve al suo scopo.

  1. Si connette via SSH (usando Jsch) a un server (usando un file chiave privata – mykey.pem)
  2. Crea uno script di shell (per montare un volume e mkfs)
  3. Funziona sulla macchina remota
  4. Nel frattempo puoi vedere l’output sul tuo stdout

Il codice segue:

 public class connectSSH { public void connect(String dnsName, String privKey) throws IOException { JSch jSch = new JSch(); try { //Authenticate through Private Key File jSch.addIdentity(privKey); //Give the user and dnsName Session session = jSch.getSession("root", dnsName, 22); //Required if not a trusted host java.util.Properties config = new java.util.Properties(); config.put("StrictHostKeyChecking", "no"); session.setConfig(config); System.out.println("Connecting SSH to " + dnsName + " - Please wait for few minutes... "); session.connect(); //Open a shell Channel channel=session.openChannel("shell"); channel.setOutputStream(System.out); //Create a Shell Script File shellScript = createShellScript(); //Convert the shell script to byte stream FileInputStream fin = new FileInputStream(shellScript); byte fileContent[] = new byte[(int)shellScript.length()]; fin.read(fileContent); InputStream in = new ByteArrayInputStream(fileContent); //Set the shell script to the channel as input stream channel.setInputStream(in); //Connect and have fun! channel.connect(); } catch (JSchException e) { // TODO Auto-generated catch block e.printStackTrace(); } } public File createShellScript() { String filename = "shellscript.sh"; File fstream = new File(filename); try{ // Create file PrintStream out = new PrintStream(new FileOutputStream(fstream)); out.println("#!/bin/bash"); out.println("echo \"hi\" > /tmp/test.info"); out.println("echo \"n\" > /tmp/fdisk.in"); out.println("echo \"p\" >> /tmp/fdisk.in"); out.println("echo \"1\" >> /tmp/fdisk.in"); out.println("echo >> /tmp/fdisk.in"); out.println("echo >> /tmp/fdisk.in"); out.println("echo \"w\" >> /tmp/fdisk.in"); out.println("/sbin/fdisk /dev/sdf < /tmp/fdisk.in"); out.println("mkfs.ext3 /dev/sdf1"); out.println("mkdir /usr/myebs"); out.println("mount /dev/sdf1 /usr/myebs"); out.println("partprobe /dev/sdf1"); out.println("echo \"Success\""); //Close the output stream out.close(); }catch (Exception e){//Catch exception if any System.err.println("Error: " + e.getMessage()); } return fstream; } public static void main(String[] args) { connectSSH ssh = new connectSSH(); String privKey = "/Users/neo/Desktop/mykey.pem"; try { ssh.connect("yourexampleserver.com", privKey); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } 

Con i flussi di input e output convogliati sembra interessante:

 JSch jsch = new JSch(); jsch.addIdentity("/home/audrius/.ssh/blablabla", "blablablabla"); String user = "audrius"; String host = "ultrastudio.org"; Session session = jsch.getSession(user, host, 439); session.setConfig("StrictHostKeyChecking", "no"); session.connect(); Channel channel = session.openChannel("shell"); PipedInputStream pip = new PipedInputStream(40); channel.setInputStream(pip); PipedOutputStream pop = new PipedOutputStream(pip); PrintStream print = new PrintStream(pop); channel.setOutputStream(System.out); print.println("ls"); 

prova questo

 Channel channel=session.openChannel("shell"); OutputStream ops = channel.getOutputStream(); PrintStream ps = new PrintStream(ops, true); channel.connect(); ps.println("mkdir folder"); ps.println("dir"); //give commands to be executed inside println.and can have any no of commands sent. ps.close(); InputStream in=channel.getInputStream(); byte[] bt=new byte[1024]; while(true) { while(in.available()>0) { int i=in.read(bt, 0, 1024); if(i<0) break; String str=new String(bt, 0, i); //displays the output of the command executed. System.out.print(str); } if(channel.isClosed()) { break; } Thread.sleep(1000); channel.disconnect(); session.disconnect(); } 

Mi rendo conto che questo è un vecchio thread, ma oggi ho faticato con un problema simile. Questa è la mia soluzione.

 public class ChannelConsole { // ================================================ // static fields // ================================================ // ================================================ // instance fields // ================================================ private Session session; // ================================================ // constructors // ================================================ public ChannelConsole(Session session) { this.session = session; } // ================================================ // getters and setters // ================================================ // ================================================ // public methods // ================================================ public String execute(String command) throws JSchException { command = command.trim() + "\n"; ChannelExec channel = (ChannelExec) this.session.openChannel("exec"); channel.setCommand(command); ByteArrayOutputStream responseStream = new ByteArrayOutputStream(); channel.setOutputStream(responseStream); channel.connect(); try { awaitChannelClosure(channel); } catch (InterruptedException e) { // no one cares } String result = responseStream.toString(); closeQuietly(responseStream); return result; } // ================================================ // private methods // ================================================ private void awaitChannelClosure(ChannelExec channel) throws InterruptedException { while (channel.isConnected()) { Thread.sleep(100); } } private static void closeQuietly(Closeable closeable) { if (closeable == null) { return; } try { closeable.close(); } catch (IOException ignored) { ignored.printStackTrace(); } } } 

Usando questa class puoi fare qualcosa come: shell = new ChannelConsole(this.session); String result = shell.execute("quota -v; echo; echo \"Disk storage information:\"; df -hk") shell = new ChannelConsole(this.session); String result = shell.execute("quota -v; echo; echo \"Disk storage information:\"; df -hk")

Uso:

 String remoteCommandOutput = exec("ssh://user:[email protected]/work/dir/path", "ls -t | head -n1"); String remoteShellOutput = shell("ssh://user:[email protected]/work/dir/path", "ls") shell("ssh://user:[email protected]/work/dir/path", "ls", System.out) shell("ssh://user:[email protected]", System.in, System.out); 

Implementazione

prova questo codice:

  JSch jsch=new JSch(); System.out.println("Getting session"); Session session=jsch.getSession("root","10.0.0.0",22); System.out.println("session is ::::"+session.getHost()); // username and password will be given via UserInfo interface. UserInfo ui = new MyUserInfo("[email protected]", null); //UserInfo ui = new MyUserInfo(password, null); session.setUserInfo(ui); session.setPassword("[email protected]"); Properties config = new java.util.Properties(); config.put("StrictHostKeyChecking", "no"); session.setConfig(config); session.connect(40000); Channel channel=session.openChannel("exec"); ((ChannelExec)channel).setCommand("ls"); channel.connect(); channel.run(); // get I/O streams for remote scp OutputStream out=channel.getOutputStream(); InputStream in=channel.getInputStream(); String output=""; while (channel.isClosed()!=true) { try { output+=streamToString(in); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } System.out.println("Output is :::"+output); channel.disconnect(); session.disconnect(); } public static String streamToString(InputStream input)throws Exception { String output = ""; while(input.available()>0) { output += ((char)(input.read())); } return output; } public static OutputStream stringToStream(String charset) throws IOException{ byte[] bytes = charset.getBytes(); /*ByteArrayInputStream bais = new ByteArrayInputStream(bytes); InputStreamReader isr = new InputStreamReader(bais);*/ InputStream is = null; OutputStream os = null; try { is = new ByteArrayInputStream(charset.getBytes("UTF-8")); } catch (UnsupportedEncodingException e) { // TODO Auto-generated catch block e.printStackTrace(); } //byte[] buf = new byte[1024]; int numRead; while ( (numRead = is.read(bytes) ) >= 0) { os.write(bytes, 0, numRead); } return os;