legacy/org.argeo.slc.support/src/org/argeo/slc/jsch/AbstractJschTask.java

   1 package org.argeo.slc.jsch;
   2
   3 import java.io.IOException;
   4 import java.io.InputStream;
   5 import java.security.PrivilegedAction;
   6
   7 import org.argeo.api.cms.CmsLog;
   8 import org.argeo.slc.SlcException;
   9
  10 import com.jcraft.jsch.JSch;
  11 import com.jcraft.jsch.JSchException;
  12 import com.jcraft.jsch.Logger;
  13 import com.jcraft.jsch.Session;
  14 import com.jcraft.jsch.UserAuthGSSAPIWithMIC;
  15
  16 public abstract class AbstractJschTask implements Runnable {
  17         private final CmsLog log = CmsLog.getLog(getClass());
  18
  19         private SshTarget sshTarget;
  20
  21         protected Session openSession() {
  22                 if (sshTarget.getSession() != null) {
  23                         Session session = sshTarget.getSession();
  24                         if (session.isConnected()) {
  25                                 if (log.isTraceEnabled())
  26                                         log.debug("Using cached session to " + getSshTarget() + " via SSH");
  27                                 return session;
  28                         }
  29                 }
  30
  31                 try {
  32                         JSch jsch = new JSch();
  33                         if (sshTarget.getUsePrivateKey() && sshTarget.getLocalPrivateKey().exists())
  34                                 jsch.addIdentity(sshTarget.getLocalPrivateKey().getAbsolutePath());
  35                         Session session = jsch.getSession(getSshTarget().getUser(), getSshTarget().getHost(),
  36                                         getSshTarget().getPort());
  37
  38                         session.setUserInfo(getSshTarget().getUserInfo());
  39                         session.setConfig("userauth.gssapi-with-mic", UserAuthGSSAPIWithMIC.class.getName());
  40                         session.setServerAliveInterval(1000);
  41                         session.connect();
  42                         if (log.isTraceEnabled())
  43                                 log.trace("Connected to " + getSshTarget() + " via SSH");
  44                         if (sshTarget.getSession() != null) {
  45                                 if (log.isTraceEnabled())
  46                                         log.trace("The cached session to " + getSshTarget() + " was disconnected and was reset.");
  47                                 sshTarget.setSession(session);
  48                         }
  49                         return session;
  50                 } catch (JSchException e) {
  51                         if (sshTarget.getUserInfo() instanceof SimpleUserInfo)
  52                                 ((SimpleUserInfo) sshTarget.getUserInfo()).reset();
  53                         throw new SlcException("Could not open session to " + getSshTarget(), e);
  54                 }
  55         }
  56
  57         public void run() {
  58                 Session session = openSession();
  59                 try {
  60                         run(session);
  61                 } finally {
  62                         if (sshTarget != null && sshTarget.getSession() == null) {
  63                                 session.disconnect();
  64                                 if (log.isTraceEnabled())
  65                                         log.trace("Disconnected from " + getSshTarget() + " via SSH");
  66                         }
  67                 }
  68         }
  69
  70         abstract void run(Session session);
  71
  72         protected int checkAck(InputStream in) throws IOException {
  73                 int b = in.read();
  74                 // b may be 0 for success,
  75                 // 1 for error,
  76                 // 2 for fatal error,
  77                 // -1
  78                 if (b == 0)
  79                         return b;
  80                 else if (b == -1)
  81                         return b;// throw new SlcException("SSH ack returned -1");
  82                 else if (b == 1 || b == 2) {
  83                         StringBuffer sb = new StringBuffer();
  84                         int c;
  85                         do {
  86                                 c = in.read();
  87                                 sb.append((char) c);
  88                         } while (c != '\n');
  89                         if (b == 1) { // error
  90                                 throw new SlcException("SSH ack error: " + sb.toString());
  91                         }
  92                         if (b == 2) { // fatal error
  93                                 throw new SlcException("SSH fatal error: " + sb.toString());
  94                         }
  95                 }
  96                 return b;
  97         }
  98
  99         public SshTarget getSshTarget() {
 100                 if (sshTarget == null)
 101                         throw new SlcException("No SSH target defined.");
 102                 return sshTarget;
 103         }
 104
 105         public void setSshTarget(SshTarget sshTarget) {
 106                 this.sshTarget = sshTarget;
 107         }
 108
 109         PrivilegedAction<Void> asPrivilegedAction() {
 110                 return new PrivilegedAction<Void>() {
 111                         public Void run() {
 112                                 AbstractJschTask.this.run();
 113                                 return null;
 114                         }
 115                 };
 116         }
 117
 118         static {
 119                 JSch.setLogger(new JschLogger());
 120         }
 121
 122         private static class JschLogger implements Logger {
 123                 private final CmsLog log = CmsLog.getLog(JschLogger.class);
 124
 125                 // TODO better support levels
 126                 @Override
 127                 public boolean isEnabled(int level) {
 128                         if (log.isTraceEnabled())
 129                                 return true;
 130                         return false;
 131                 }
 132
 133                 @Override
 134                 public void log(int level, String message) {
 135                         log.trace(message);
 136                 }
 137
 138         }
 139 }