Java 类com.jcraft.jsch.agentproxy.ConnectorFactory 实例源码

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

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

@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;
}

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

/**
 * 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;
    }
}

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