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

public OpenSSHAgentAuthenticator() {
    try {
        proxy = new AgentProxy(new SSHAgentConnector(new JNAUSocketFactory()));
    }
    catch(AgentProxyException e) {
        log.warn(String.format("Agent proxy %s failed with %s", this, e));
    }
}

public PageantAuthenticator() {
    try {
        this.proxy = new AgentProxy(new PageantConnector());
    }
    catch(AgentProxyException e) {
        log.warn(String.format("Agent proxy %s failed with %s", this, e));
    }
}

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

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

public static void main(String[] args) throws AgentProxyException, IOException, JSchException
    {
        HostAndPort hostAndPort = HostAndPort.fromParts("ec2-54-83-158-5.compute-1.amazonaws.com", 22);
        LoginCredentials loginCredentials = LoginCredentials.builder().privateKey(System.getProperty("user.home") + "/.ec2/leite.pem").user("ubuntu")
                .build();

        SshClient client = SshClientFactory.defaultSshClientFactory().create(hostAndPort, loginCredentials);
        client.connect();

        ExecutableResponse response = client.execute("uname -a && date && uptime && who");
        System.out.println(response);

//        final OnlineChannel shell = client.shell();
//        shell.getInput().write("sudo apt-get install maven -y\n".getBytes());
//        shell.getInput().flush();
//
//        Thread t = new Thread(new Runnable()
//        {
//            @Override
//            public void run()
//            {
//                while (true)
//                {
//                    BufferedReader reader = new BufferedReader(new InputStreamReader(shell.getOutput(), Charsets.US_ASCII));
//                    String line;
//                    try
//                    {
//                        while ((line = reader.readLine()) != null)
//                        {
//                            System.out.println(line);
//                        }
//                    }
//                    catch (IOException e)
//                    {
//                        e.printStackTrace();
//                    }
//                }
//            }
//        });
//        t.setDaemon(true);
//        t.start();

        client.put("/home/ubuntu/hi.txt", "Hi node!");

        client.disconnect();

        // JSch jsch = new JSch();
        // jsch.addIdentity(loginCredentials.getPrivateKey());
        //
        // Session session = jsch.getSession(loginCredentials.getUser(), hostAndPort.getHostText());
        //
        // Properties config = new Properties();
        // config.put("StrictHostKeyChecking", "no");
        //
        // session.setConfig(config);
        // session.connect();
        //
        // Channel shell = session.openChannel("shell");
        // shell.setInputStream(System.in);
        // shell.setOutputStream(System.out);
        // shell.connect(0);

    }