L'envoi de commandes au serveur via JSch shell canal

Si elle bloque readLine() cela signifie que votre "tout" ne se termine jamais (peut-être peu probable compte tenu de votre code), ou, readLine() est en attente de sa source, à savoir le IOstream bloque le thread cause available()!=true.

Je n'arrive pas à résoudre vos problèmes de code sans voir vos informations de débogage. Mais comme un conseil, avez-vous essayé PipedIntputStream? L'idée est de tuyau de votre console d'entrée à "votre" sortie de sorte que vous pouvez "écrire" il. Pour ce faire, vous devez initialiser le in/out-put.

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

Il en va de même à votre question, comment faire pour lire la sortie de la console.

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

Et encore une fois, si vous n'êtes pas sûr de savoir comment beaucoup de lignes à lire et donc à utiliser "bien que", assurez-vous de faire quelque chose à l'intérieur tout pour empêcher 1) occupé-en attente 2) la fin de condition. Exemple:

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

Qui suit a été rapidement un code écrit pour ma mission. Pas un bien fait programme.
Mais il sert son but.

1. Se connecte via SSH (à l'aide de Jsch) à un serveur (à l'aide d'un Fichier de Clé Privée - maclé.pem)
2. Crée un script shell (pour monter un volume et mkfs)
3. S'exécute sur l'ordinateur distant
4. Pendant tout ce temps vous pouvez voir le résultat sur votre stdout

Le code suivant:

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();
}
}
}

Avec les canalisations d'entrée et de sortie des flux semble intéressant:

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");

essayer cette

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();   
}

essayez ce code :

         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("Lab@123", null);
//UserInfo ui = new MyUserInfo(password, null);
session.setUserInfo(ui);
session.setPassword("Lab@123");
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;