org.eclipse.jgit.api.errors.InvalidRemoteException Java Examples

private File cloneToTmpDir(String pathToRemoteGitRepository) throws GitAPIException, InvalidRemoteException, TransportException {
	File localDir;
	TmpDirCreator tmpDirCreator = new TmpDirCreator(pathToRemoteGitRepository);
	localDir = tmpDirCreator.getLocalTempDir();
	if(!localDir.exists()){
		messageOutputStream.println("Caching git repository " + pathToRemoteGitRepository + "...");
		Git.cloneRepository().setURI(pathToRemoteGitRepository)
							 .setDirectory(localDir)
							 .setProgressMonitor(new GitProgressMonitor())
							 .call();
		localDir.mkdirs();
		messageOutputStream.println("\nCaching finished succesfully...");
		tmpDirCreator.writeIdFileToTempDir();
	}
	return localDir;
}
 

public static boolean cloneRepository(String remoteUrl, String branch, String projectPath, String user, String pwd) throws InvalidRemoteException, TransportException, GitAPIException {
   	File projectDir = new File(projectPath);

       UsernamePasswordCredentialsProvider provider = new UsernamePasswordCredentialsProvider(user, pwd);
       try (Git git = Git.cloneRepository()
               .setURI(remoteUrl)
               .setBranch(branch)
               .setDirectory(projectDir)
               .setCredentialsProvider(provider)
               .setProgressMonitor(new CloneProgressMonitor())
               .call()) {
       	
       }
       
       return true;
}
 

private Git refreshRepository(GitSyncDetails syncDetails, File syncDir)
		throws GitAPIException, InvalidRemoteException, TransportException, IOException,
		WrongRepositoryStateException, InvalidConfigurationException, CanceledException, RefNotFoundException,
		RefNotAdvertisedException, NoHeadException {
	Git repo;
	if (!syncDir.exists()) {
		syncDir.mkdirs();
		repo = initWith(Git.cloneRepository(), syncDetails)
			.setURI(syncDetails.getGitUrl())
			.setDirectory(syncDir)
			.setCloneAllBranches(true)
			.setBranch("master")
			.call();
		
		
	} else {
		repo = Git.open(syncDir);
		initWith(repo.pull(), syncDetails)
			.call();
	}
	return repo;
}
 

public void pushToRepo() throws IOException, JGitInternalException, InvalidRemoteException, GitAPIException {
	PushCommand pc = git.push();
	pc.setCredentialsProvider(cp).setForce(true).setPushAll();
	try {
		Iterator<PushResult> it = pc.call().iterator();
		if (it.hasNext()) {
			System.out.println(it.next().toString());
		}
	} catch (InvalidRemoteException e) {
		e.printStackTrace();
	}
}
 

/**
   * Initializes a user's git repository.
   * 
   * 
   * @param workspacePath
   * @param userId
   * @param email
   * @return
   * @throws IOException
   * @throws InvalidRemoteException
   * @throws TransportException
   * @throws GitAPIException
   */
  private static Path initializeUserRepository(Path workspacePath, String userId, URI email) throws IOException, InvalidRemoteException, TransportException, GitAPIException {
  	Path gitPath = null;
//
// Initialize the User's Git repository
//
if (Files.notExists(workspacePath)) {
	logger.info("Creating user workspace: " + workspacePath.toAbsolutePath().toString());
	//
	// Create our user's directory
	//
	Files.createDirectory(workspacePath);
}
gitPath = Paths.get(workspacePath.toString(), XacmlAdminUI.repositoryPath.getFileName().toString());
if (Files.notExists(gitPath)) {
	//
	// It doesn't exist yet, so Clone it and check it out
	//
	logger.info("Cloning user git directory: " + gitPath.toAbsolutePath().toString());
	Git.cloneRepository().setURI(XacmlAdminUI.repositoryPath.toUri().toString())
					.setDirectory(gitPath.toFile())
					.setNoCheckout(false)
					.call();
	//
	// Set userid
	//
	Git git = Git.open(gitPath.toFile());
	StoredConfig config = git.getRepository().getConfig();
	config.setString("user", null, "name", userId);
	if (email != null && email.getPath() != null) {
		config.setString("user", null, "email", email.toString());
	}
	config.save();
}
return gitPath;
  }
 

@Override
public FetchResult call()
		throws GitAPIException, InvalidRemoteException, TransportException {
	try {
		Thread.sleep(250);
	}
	catch (InterruptedException e) {
		e.printStackTrace();
	}
	return super.call();
}
 

@Override
public Git call()
		throws GitAPIException, InvalidRemoteException, TransportException {
	try {
		Thread.sleep(250);
	}
	catch (InterruptedException e) {
		e.printStackTrace();
	}
	return super.call();
}
 

public static void gitSync() throws IOException, InvalidRemoteException, org.eclipse.jgit.api.errors.TransportException, GitAPIException {
	SshSessionFactory.setInstance(new JschConfigSessionFactory() {
		  public void configure(Host hc, Session session) {
		    session.setConfig("StrictHostKeyChecking", "no");
		  };
		}
	);
	if (openRepository()) {
		pullRepository();
	}
	else cloneRepository();
}
 

public static void clone(String[] args)
			throws IOException, InvalidRemoteException, TransportException, GitAPIException {
		// prepare a new folder for the cloned repository
		String localPath = args[1];
		String url = args[0];
		File localGitDir = new File(localPath + "/.git");
		// then clone
		Git result = null;

		java.lang.System.setProperty("https.protocols", "TLSv1,TLSv1.1,TLSv1.2");
		try {
			result = Git.cloneRepository().setURI(url).setBare(true).setDirectory(localGitDir).call();
			// Note: the call() returns an opened repository already which
			// needs
			// to be closed to avoid file handle leaks!
			// workaround for
			// https://bugs.eclipse.org/bugs/show_bug.cgi?id=474093
			result.getRepository().close();
			/*
		} catch (Exception e) {
			System.err.println("Error cloning " + url);
			e.printStackTrace();
			*/
		} finally {
			if (result != null && result.getRepository() != null) {
//				System.out.println("Cloned repo " + url);
				result.getRepository().close();
			}
		} 
	}
 

public void clone(int from, int to)
		throws InvalidRemoteException, TransportException, IOException, GitAPIException {
	String urlHeader = "https://github.com/";
	String urlFooter = ".git";
	String outFilePath = "";
	File dir = new File(inPath);
	File[] files = dir.listFiles();
	for (int i = from; i < to; i++) {
		// System.out.println("Processing file number " + i );
		if (!files[i].getName().endsWith(".json")) {
			continue;
		}
		String content = FileIO.readFileContents(files[i]);
		Gson parser = new Gson();
		JsonArray repos = parser.fromJson(content, JsonElement.class).getAsJsonArray();
		for (int j = 0; j < repos.size(); j++) {
			JsonObject repo = repos.get(j).getAsJsonObject();
			String name = repo.get("full_name").getAsString();
			boolean forked = repo.get("fork").getAsBoolean();
			if (forked)
				continue;
			outFilePath = outPath + "/" + name;
			//File file = new File(outFilePath);
			if (names.contains(name)){
				names.remove(name);
				continue;
			}
			String[] args = { urlHeader + name + urlFooter, outFilePath };
			RepositoryCloner.clone(args);
			FileIO.writeFileContents(recovory, name + "/n" , true);
		}
	}
}
 

private static void pull(final Git git, ProgressMonitor monitor)
		throws GitAPIException, WrongRepositoryStateException,
		InvalidConfigurationException, InvalidRemoteException, CanceledException, RefNotFoundException,
		RefNotAdvertisedException, NoHeadException, TransportException {

	git.pull().setTransportConfigCallback(TRANSPORT_CALLBACK).setProgressMonitor(monitor).call();
}
 

private static void pull(final Git git, IProgressMonitor monitor)
		throws GitAPIException, WrongRepositoryStateException,
		InvalidConfigurationException, InvalidRemoteException, CanceledException, RefNotFoundException,
		RefNotAdvertisedException, NoHeadException, TransportException {

	@SuppressWarnings("restriction")
	ProgressMonitor gitMonitor = (null == monitor) ? createMonitor()
			: new org.eclipse.egit.core.EclipseGitProgressTransformer(monitor);
	pull(git, gitMonitor);
}
 

public static boolean pull(String projectPath, String branch, String user, String pwd) throws IOException, WrongRepositoryStateException, InvalidConfigurationException, InvalidRemoteException, CanceledException, RefNotFoundException, RefNotAdvertisedException, NoHeadException, TransportException, GitAPIException {

		try (Git git = Git.open(new File(projectPath)) ) {
			UsernamePasswordCredentialsProvider provider = new UsernamePasswordCredentialsProvider(user, pwd);
			git.pull().setRemoteBranchName(branch)
					.setCredentialsProvider(provider)
					.setProgressMonitor(new PullProgressMonitor())
					.call();
		}
		
		return true;
	}
 

public void setGitCadEngine(String gitsId, String file, DHParameterKinematics dh)
		throws InvalidRemoteException, TransportException, GitAPIException, IOException {
	baseManager.setGitCadEngine(gitsId, file, dh);
}
 

public void pullFromRepo()
		throws IOException, WrongRepositoryStateException, InvalidConfigurationException, DetachedHeadException,
		InvalidRemoteException, CanceledException, RefNotFoundException, NoHeadException, GitAPIException {
	git.pull().call();
}
 

public void setGitCadEngine(String gitsId, String file, MobileBase device)
		throws InvalidRemoteException, TransportException, GitAPIException, IOException {
	baseManager.setGitCadEngine(gitsId, file, device);
}
 

private static void openCadTab(CreatureLab creatureLab, String gitsId, String file)
		throws InvalidRemoteException, TransportException, GitAPIException, IOException {
	File code = ScriptingEngine.fileFromGit(gitsId, file);
	ScriptingFileWidget wid = BowlerStudio.createFileTab(code);

}
 

@Test
public void pullTest() throws InvalidRemoteException, TransportException, GitAPIException, IOException {
    GitPull.create().quickPull();
}
 

private static void pull(final Git git) throws GitAPIException, WrongRepositoryStateException,
		InvalidConfigurationException, InvalidRemoteException, CanceledException, RefNotFoundException,
		RefNotAdvertisedException, NoHeadException, TransportException {

	pull(git, (ProgressMonitor) null);
}
 

@Override
public Git call() throws GitAPIException, InvalidRemoteException {
	return this.mockGit;
}
 

@Test(expected = InvalidRemoteException.class)
public void changeURITest() throws Exception {
    wfRepo.setOriginURI(wfRepo.getOriginUri() + "ERROR_TEST");
    defaultBranchTest();
}