Java Connector类代码示例

import com.jcraft.jsch.agentproxy.Connector; //导入依赖的package包/类
private boolean setupJSchIdentityRepository (JSch jsch, String identityFile, boolean preferAgent) throws JSchException {
    boolean agentUsed = false;
    if (preferAgent) {
        Connector con = ConnectorFactory.getInstance().createConnector(ConnectorFactory.ConnectorKind.ANY);
        if (con != null) {
            IdentityRepository irepo = new IdentityRepositoryImpl(con);
            if (irepo.getStatus() == IdentityRepository.RUNNING) {
                jsch.setIdentityRepository(irepo);
                agentUsed = true;
            }
        }
    }
    if (!agentUsed) {
        jsch.setIdentityRepository(null);
        // remove all identity files
        jsch.removeAllIdentity();
        // and add the one specified by CredentialsProvider
        jsch.addIdentity(identityFile);
    }
    return agentUsed;
}
 

import com.jcraft.jsch.agentproxy.Connector; //导入依赖的package包/类
private Session initSessionSshAgent(String username, String socketPath, JSch jsch) throws JSchException {
  final Session session = jsch.getSession(username, myHost, myPort);
  session.setConfig("PreferredAuthentications", "publickey");

  try {
    ConnectorFactory cf = ConnectorFactory.getDefault();
    cf.setUSocketPath(socketPath);
    Connector con = cf.createConnector();
    IdentityRepository irepo = new RemoteIdentityRepository(con);
    jsch.setIdentityRepository(irepo);
    return session;
  } catch (AgentProxyException e) {
    throw new JSchException("Failed to connect to ssh agent.", e);
  }
}
 

import com.jcraft.jsch.agentproxy.Connector; //导入依赖的package包/类
public JschSshClient(HostAndPort socket, LoginCredentials loginCredentials, int timeout, Optional<Connector> agentConnector,
        BackoffLimitedRetryHandler backoffLimitedRetryHandler)
{
    this.host = checkNotNull(socket, "host").getHost();
    this.user = checkNotNull(loginCredentials, "credentials for %s", host).getUser();
    checkArgument(socket.getPort() > 0, "ssh port must be greater than zero" + socket.getPort());
    checkArgument(socket.getPort() < 65535, "ssh port must be less than 65535" + socket.getPort());
    this.backoffLimitedRetryHandler = checkNotNull(backoffLimitedRetryHandler, "backoffLimitedRetryHandler");

    connection = SshConnection.builder()
            .hostAndPort(socket)
            .loginCredentials(loginCredentials)
            .connectionTimeout(timeout)
            .agentConnector(agentConnector)
            .build();
    
    checkNotNull(connection);
}
 

import com.jcraft.jsch.agentproxy.Connector; //导入依赖的package包/类
private Session newSession() throws JSchException {
    JSch jSch = new JSch();
    try {
        jSch.setConfig("PreferredAuthentications", "publickey");

        if (hostInfo.isDoHostKeyChecks()) {
            jSch.setKnownHosts(userInfo.sshFolderLocation() + File.separator + "known_hosts");
        } else {
            jSch.setHostKeyRepository(new FakeHostKeyRepository());
        }

        if (userInfo.isUseAgentIdentities()) {
            Connector connector = ConnectorFactory.getDefault().createConnector();
            if (connector != null) {
                IdentityRepository identityRepository = new RemoteIdentityRepository(connector);
                jSch.setIdentityRepository(identityRepository);
            }
        }

        // add private key to the IdentityRepository. If using agent identities, this will add the private
        // key to the agent, if it is not already present.
        jSch.addIdentity(userInfo.privateKeyLocation().getAbsolutePath());

        session = jSch.getSession(userInfo.getUserName(), hostInfo.getHostname(), hostInfo.getPort());
        Long timeout = TimeUnit.SECONDS.toMillis(hostInfo.getTimeoutSeconds());
        session.setTimeout(timeout.intValue());
        session.setUserInfo(new PasswordlessEnabledUser(userInfo.getPassphrase()));
        return session;
    } catch (JSchException | AgentProxyException e) {
        String msg = ExecutionFailedException.userFriendlyCause(e.getMessage(), hostInfo.getHostname(), userInfo);
        throw new ExecutionFailedException(msg, e);
    }
}
 

import com.jcraft.jsch.agentproxy.Connector; //导入依赖的package包/类
public RemoteClient(Environment environment, DeploymentContext context, Logger logger) throws RemoteClientException {
    RemoteClient instance = this;

    Runtime.getRuntime().addShutdownHook(new Thread() {
        public void run() {
            instance.tryDisconnect();
        }
    });

    this.logger = logger;

    try {
        JSch shellClient = new JSch();
        shellClient.setKnownHosts(new FileInputStream(new File(System.getenv("HOME") + "/.ssh/known_hosts")));
        ConnectorFactory connectorFactory = ConnectorFactory.getDefault();
        Connector connector = connectorFactory.createConnector();
        Properties config = new java.util.Properties();
        config.put("PreferredAuthentications", "publickey");

        if (context.project().options().containsKey("check_host_keys")) {
            String option = (boolean) context.project().options().get("check_host_keys") ? "yes" : "no";
            JSch.setConfig("StrictHostKeyChecking", option);
            if (option.equals("no")) {
                logger.warn("WARNING: host key check is disabled!");
            }
        }

        if (connector != null) {
            IdentityRepository remoteIdentityRepository = new RemoteIdentityRepository(connector);
            shellClient.setIdentityRepository(remoteIdentityRepository);
        }
        for (Target target : environment.targets()) {
            sessions.add(new RemoteTarget(connect(shellClient, target, context, config), target, context, environment));
        }
    } catch (AgentProxyException | FileNotFoundException | JSchException e) {
        throw new RemoteClientException(e.getMessage());
    }
}
 

import com.jcraft.jsch.agentproxy.Connector; //导入依赖的package包/类
@Nullable
private static Connector createSshAgentConnector() {
  Connector result = null;

  try {
    result = ConnectorFactory.getDefault().createConnector();
  }
  catch (AgentProxyException e) {
    LOG.info("Could not create ssh agent connector", e);
  }

  return result;
}
 

import com.jcraft.jsch.agentproxy.Connector; //导入依赖的package包/类
/**
 * Attempts to connect to a local SSH agent (using either UNIX sockets or PuTTY's Pageant)
 *
 * @param jsch
 *            Connection to be attached to an available local agent
 * @return true if connected to agent, false otherwise
 */
private boolean attemptAgentUse(JSch jsch) {
    try {
        Connector con = ConnectorFactory.getDefault().createConnector();
        jsch.setIdentityRepository(new RemoteIdentityRepository(con));
        return true;
    } catch (Exception e) {
        Message.verbose(":: SSH :: Failure connecting to agent :: " + e.toString());
        return false;
    }
}
 

import com.jcraft.jsch.agentproxy.Connector; //导入依赖的package包/类
public static SshClient.Factory defaultSshClientFactory()
{
    return new SshClient.Factory()
    {
        int timeout = SystemUtils2.getIntegerProperty("org.excalibur.ssh.default.connection.timeout.ms", 60000);

        Optional<Connector> agentConnector = getAgentConnector();

        @Override
        public boolean isAgentAvailable()
        {
            return agentConnector.isPresent();
        }

        @Override
        public SshClient create(HostAndPort socket, LoginCredentials credentials)
        {
            return new JschSshClient(socket, credentials, timeout, agentConnector, new BackoffLimitedRetryHandler());
        }

        Optional<Connector> getAgentConnector()
        {
            try
            {
                return Optional.of(ConnectorFactory.getDefault().createConnector());
            }
            catch (final AgentProxyException e)
            {
                return Optional.absent();
            }
        }
    };
}
 

import com.jcraft.jsch.agentproxy.Connector; //导入依赖的package包/类
private SshConnection(HostAndPort hostAndPort, LoginCredentials loginCredentials, Optional<Proxy> proxy, int connectTimeout, int sessionTimeout,
        Optional<Connector> agentConnector)
{
    this.hostAndPort_ = checkNotNull(hostAndPort);
    this.loginCredentials_ = checkNotNull(loginCredentials, " login for %s", hostAndPort);
    this.proxy_ = checkNotNull(proxy, " proxy for %s", hostAndPort);
    this.connectTimeout_ = checkNotNull(connectTimeout);
    this.sessionTimeout_ = checkNotNull(sessionTimeout);
    this.agentConnector_ = checkNotNull(agentConnector, "agent connector for %s", hostAndPort);
}
 

import com.jcraft.jsch.agentproxy.Connector; //导入依赖的package包/类
public IdentityRepositoryImpl (Connector connector) {
    this.connector = connector;
    this.proxy = new AgentProxy(connector);
}
 

import com.jcraft.jsch.agentproxy.Connector; //导入依赖的package包/类
/**
 * @return the agentConnector
 */
public Optional<Connector> getAgentConnector()
{
    return agentConnector_;
}