import org.eclipse.jgit.transport.SshTransport; //导入依赖的package包/类
/**
 * Push all changes and tags to given remote.
 *
 * @param git
 *     instance.
 * @param remote
 *     to be used.
 * @param passphrase
 *     to access private key.
 * @param privateKey
 *     file location.
 *
 * @return List of all results of given push.
 */
public Iterable<PushResult> pushToRepository(Git git, String remote, String passphrase, Path privateKey) {
    SshSessionFactory sshSessionFactory = new JschConfigSessionFactory() {
        @Override
        protected void configure(OpenSshConfig.Host host, Session session) {
            session.setUserInfo(new PassphraseUserInfo(passphrase));
        }

        @Override
        protected JSch createDefaultJSch(FS fs) throws JSchException {
            if (privateKey != null) {
                JSch defaultJSch = super.createDefaultJSch(fs);
                defaultJSch.addIdentity(privateKey.toFile().getAbsolutePath());
                return defaultJSch;
            } else {
                return super.createDefaultJSch(fs);
            }
        }
    };

    try {
        return git.push()
            .setRemote(remote)
            .setPushAll()
            .setPushTags()
            .setTransportConfigCallback(transport -> {
                SshTransport sshTransport = (SshTransport) transport;
                sshTransport.setSshSessionFactory(sshSessionFactory);
            })
            .call();
    } catch (GitAPIException e) {
        throw new IllegalStateException(e);
    }
}
 

import org.eclipse.jgit.transport.SshTransport; //导入依赖的package包/类
private void initSessionFactory() {
    JschConfigSessionFactory sshSessionFactory = new JschConfigSessionFactory() {
        @Override
        protected void configure(Host host, Session session) {
            session.setConfig("StrictHostKeyChecking", "no");
        }

        @Override
        protected JSch createDefaultJSch(FS fs) throws JSchException {
            JSch jSch = super.createDefaultJSch(fs);

            // apply customized private key
            if (privateKeyPath != null) {
                jSch.removeAllIdentity();
                jSch.addIdentity(privateKeyPath.toString());
            }

            return jSch;
        }
    };

    transportConfigCallback = transport -> {
        SshTransport sshTransport = (SshTransport) transport;
        sshTransport.setSshSessionFactory(sshSessionFactory);
    };
}
 

import org.eclipse.jgit.transport.SshTransport; //导入依赖的package包/类
public static TransportConfigCallback getTransportConfigCallback() {
    final SshSessionFactory sshSessionFactory = new JschConfigSessionFactory() {
        @Override
        protected void configure(OpenSshConfig.Host host, Session session) {
            //session.setPassword(password);
        }
    };
    return new TransportConfigCallback() {

        public void configure(Transport transport) {
            if (transport instanceof TransportHttp)
                return;
            SshTransport sshTransport = (SshTransport) transport;
            sshTransport.setSshSessionFactory(sshSessionFactory);
        }
    };
}
 

import org.eclipse.jgit.transport.SshTransport; //导入依赖的package包/类
/**
 * Pull repository from current branch and remote branch with same name as current
 *
 * @param git
 *     instance.
 * @param remote
 *     to be used.
 * @param remoteBranch
 *     to use.
 * @param passphrase
 *     to access private key.
 * @param privateKey
 *     file location.
 */
public PullResult pullFromRepository(final Git git, final String remote, String remoteBranch, final String passphrase,
    final Path privateKey) {
    SshSessionFactory sshSessionFactory = new JschConfigSessionFactory() {
        @Override
        protected void configure(OpenSshConfig.Host host, Session session) {
            session.setUserInfo(new PassphraseUserInfo(passphrase));
        }

        @Override
        protected JSch createDefaultJSch(FS fs) throws JSchException {
            if (privateKey != null) {
                JSch defaultJSch = super.createDefaultJSch(fs);
                defaultJSch.addIdentity(privateKey.toFile().getAbsolutePath());
                return defaultJSch;
            } else {
                return super.createDefaultJSch(fs);
            }
        }
    };

    try {
        return git.pull()
            .setRemote(remote)
            .setRemoteBranchName(remoteBranch)
            .setTransportConfigCallback(transport -> {
                SshTransport sshTransport = (SshTransport) transport;
                sshTransport.setSshSessionFactory(sshSessionFactory);
            })
            .call();
    } catch (GitAPIException e) {
        throw new IllegalStateException(e);
    }
}
 

import org.eclipse.jgit.transport.SshTransport; //导入依赖的package包/类
/**
 * Clones a private remote git repository. Caller is responsible of closing git repository.
 *
 * @param remoteUrl
 *     to connect.
 * @param localPath
 *     where to clone the repo.
 * @param passphrase
 *     to access private key.
 * @param privateKey
 *     file location. If null default (~.ssh/id_rsa) location is used.
 *
 * @return Git instance. Caller is responsible to close the connection.
 */
public Git cloneRepository(final String remoteUrl, final Path localPath, final String passphrase,
    final Path privateKey) {

    SshSessionFactory sshSessionFactory = new JschConfigSessionFactory() {
        @Override
        protected void configure(OpenSshConfig.Host host, Session session) {
            session.setUserInfo(new PassphraseUserInfo(passphrase));
        }

        @Override
        protected JSch createDefaultJSch(FS fs) throws JSchException {
            if (privateKey != null) {
                JSch defaultJSch = super.createDefaultJSch(fs);
                defaultJSch.addIdentity(privateKey.toFile().getAbsolutePath());
                return defaultJSch;
            } else {
                return super.createDefaultJSch(fs);
            }
        }
    };

    try {
        return Git.cloneRepository()
            .setURI(remoteUrl)
            .setTransportConfigCallback(transport -> {
                SshTransport sshTransport = (SshTransport) transport;
                sshTransport.setSshSessionFactory(sshSessionFactory);
            })
            .setDirectory(localPath.toFile())
            .call();
    } catch (GitAPIException e) {
        throw new IllegalStateException(e);
    }
}
 

import org.eclipse.jgit.transport.SshTransport; //导入依赖的package包/类
@Test
public void shouldSetSshSessionFactoryWhenSshTransportReceived() throws Exception {
  // given
  SshTransport sshTransport = mock(SshTransport.class);
  when(sshKeyProvider.getPrivateKey(anyString())).thenReturn(new byte[0]);
  doAnswer(
          invocation -> {
            TransportConfigCallback callback =
                (TransportConfigCallback) invocation.getArguments()[0];
            callback.configure(sshTransport);
            return null;
          })
      .when(transportCommand)
      .setTransportConfigCallback(any());

  // when
  jGitConnection.executeRemoteCommand("ssh://host.xz/repo.git", transportCommand, null, null);

  // then
  verify(sshTransport).setSshSessionFactory(any());
}
 

import org.eclipse.jgit.transport.SshTransport; //导入依赖的package包/类
/**
 * Configures the transport of the command to deal with things like SSH
 */
public static <C extends GitCommand> void configureCommand(TransportCommand<C, ?> command, CredentialsProvider credentialsProvider, final File sshPrivateKey, final File sshPublicKey) {
    if (sshPrivateKey != null) {
        final CredentialsProvider provider = credentialsProvider;
        command.setTransportConfigCallback(new TransportConfigCallback() {
            @Override
            public void configure(Transport transport) {
                if (transport instanceof SshTransport) {
                    SshTransport sshTransport = (SshTransport) transport;
                    SshSessionFactory sshSessionFactory = new JschConfigSessionFactory() {
                        @Override
                        protected void configure(OpenSshConfig.Host host, Session session) {
                            session.setConfig("StrictHostKeyChecking", "no");
                            UserInfo userInfo = new CredentialsProviderUserInfo(session, provider);
                            session.setUserInfo(userInfo);
                        }

                        @Override
                        protected JSch createDefaultJSch(FS fs) throws JSchException {
                            JSch jsch = super.createDefaultJSch(fs);
                            jsch.removeAllIdentity();
                            String absolutePath = sshPrivateKey.getAbsolutePath();
                            if (LOG.isDebugEnabled()) {
                                LOG.debug("Adding identity privateKey: " + sshPrivateKey + " publicKey: " + sshPublicKey);
                            }
                            if (sshPublicKey != null) {
                                jsch.addIdentity(absolutePath, sshPublicKey.getAbsolutePath(), null);
                            } else {
                                jsch.addIdentity(absolutePath);
                            }
                            return jsch;
                        }
                    };
                    sshTransport.setSshSessionFactory(sshSessionFactory);
                }
            }
        });
    }
}
 

import org.eclipse.jgit.transport.SshTransport; //导入依赖的package包/类
/**
 * Configures the transport to work with ssh-agent if an SSH transport is
 * being used. {@inheritDoc}
 */
@Override
public void configure(final Transport transport) {

    if (transport instanceof SshTransport) {
        final SshTransport sshTransport = (SshTransport) transport;
        final SshSessionFactory sshSessionFactory = new AgentJschConfigSessionFactory(authenticationInfo);
        sshTransport.setSshSessionFactory(sshSessionFactory);
    }
}
 

import org.eclipse.jgit.transport.SshTransport; //导入依赖的package包/类
public static File cloneRepository(String cloneUrl, String repoPw) throws GitAPIException, JSONException, IOException {
    config = ConfigParser.getConfig();
    File tmpDir = new File("temp_repo");
    String key = null;
    String keyPassPhrase = null;
    if (config.has("privateKey")) {
        key = config.getString("privateKey");
        keyPassPhrase = config.getString("privateKeyPassPhrase");
    }
    // git clone will fail if the directory already exists, even if empty
    if (tmpDir.exists()) {
        FileUtils.deleteDirectory(tmpDir);
    }
    String pw = null;
    if (repoPw != null) {
        pw = repoPw;
    }
    else if (config.has("gitClonePassword")) {
        pw = config.getString("gitClonePassword");
    }
    final String finalKeyPassPhrase = keyPassPhrase;
    final String finalKey = key;

    SshSessionFactory sessionFactory = new CustomJschConfigSessionFactory();

    // use a private key if provided
    if (finalKey != null) {
        SshSessionFactory.setInstance(sessionFactory);
    }

    // use a password if provided
    if (pw != null) {
        final String finalPw = pw;
        SshSessionFactory.setInstance(new JschConfigSessionFactory() {
            @Override
            protected void configure(OpenSshConfig.Host host, Session session) {
                session.setPassword(finalPw);
            }
        });
    }
    SshSessionFactory.setInstance(sessionFactory);
    Git.cloneRepository()
        .setURI(cloneUrl)
        .setDirectory(tmpDir)
        .setTransportConfigCallback(new TransportConfigCallback() {
            @Override
            public void configure(Transport transport) {
                SshTransport sshTransport = (SshTransport) transport;
                sshTransport.setSshSessionFactory(sessionFactory);
            }
        })
        .call();

    return tmpDir;
}
 

import org.eclipse.jgit.transport.SshTransport; //导入依赖的package包/类
public void configure(Transport tn) {
    Log.d(TAG, "Configuring " + tn);
    if (tn instanceof SshTransport) {
        ((SshTransport) tn).setSshSessionFactory(sshSessionFactory);
    }
}
 

import org.eclipse.jgit.transport.SshTransport; //导入依赖的package包/类
@Override
public void configure(Transport tn) {
    if (tn instanceof SshTransport) {
        ((SshTransport) tn).setSshSessionFactory(ssh);
    }
}