Example usage for org.eclipse.jgit.api Git reset

List of usage examples for org.eclipse.jgit.api Git reset

  1. HOME
  2. Java
  3. org.eclipse.jgit
  4. org.eclipse.jgit.api.*
  5. Git
  6. reset

Introduction

In this page you can find the example usage for org.eclipse.jgit.api Git reset.

Prototype

public ResetCommand reset()

Source Link

Document

Return a command object to execute a reset command

Usage

From source file:de.blizzy.documentr.page.CherryPicker.java

License:Open Source License

private List<CommitCherryPickResult> cherryPick(String projectName, String branchName, String path,
        List<String> commits, String targetBranch, Set<CommitCherryPickConflictResolve> conflictResolves,
        boolean dryRun, User user, Locale locale) throws IOException, GitAPIException {

    ILockedRepository repo = null;//from   w  w w .j a  v  a  2 s  .com
    List<CommitCherryPickResult> cherryPickResults = Lists.newArrayList();
    boolean hadConflicts = false;
    boolean failed = false;
    try {
        repo = globalRepositoryManager.getProjectBranchRepository(projectName, targetBranch);

        String tempBranchName = "_temp_" + String.valueOf((long) (Math.random() * Long.MAX_VALUE)); //$NON-NLS-1$
        Git git = Git.wrap(repo.r());

        git.branchCreate().setName(tempBranchName).setStartPoint(targetBranch).call();

        git.checkout().setName(tempBranchName).call();

        for (String commit : commits) {
            PageVersion pageVersion = PageUtil.toPageVersion(CommitUtils.getCommit(repo.r(), commit));
            if (!hadConflicts) {
                CommitCherryPickResult singleCherryPickResult = cherryPick(repo, branchName, path, pageVersion,
                        targetBranch, conflictResolves, user, locale);
                if (singleCherryPickResult != null) {
                    cherryPickResults.add(singleCherryPickResult);
                    if (singleCherryPickResult.getStatus() == CommitCherryPickResult.Status.CONFLICT) {
                        hadConflicts = true;
                    }
                } else {
                    failed = true;
                    break;
                }
            } else {
                cherryPickResults
                        .add(new CommitCherryPickResult(pageVersion, CommitCherryPickResult.Status.UNKNOWN));
            }
        }

        if (hadConflicts || failed) {
            git.reset().setMode(ResetCommand.ResetType.HARD).call();
        }

        git.checkout().setName(targetBranch).call();

        if (!dryRun && !hadConflicts && !failed) {
            git.merge().include(repo.r().resolve(tempBranchName)).call();
        }

        git.branchDelete().setBranchNames(tempBranchName).setForce(true).call();

        if (failed) {
            throw new IOException("cherry-picking failed"); //$NON-NLS-1$
        }
    } finally {
        Closeables.closeQuietly(repo);
    }

    if (!dryRun && !hadConflicts && !failed) {
        eventBus.post(new PageChangedEvent(projectName, targetBranch, path));
    }

    return cherryPickResults;
}

From source file:de._692b8c32.cdlauncher.tasks.GITCheckoutTask.java

License:Open Source License

@Override
public void doWork() {
    setProgress(-1);/*from   www.j  a  v a  2s .  co  m*/

    try {
        Git git = Git.open(cacheDir);
        git.reset().setMode(ResetCommand.ResetType.HARD).call();
        git.checkout().setAllPaths(true).setForce(true).setName(branch).setStartPoint(startPoint.getValue())
                .call();

        if (destinationDir != null) {
            FileUtils.delete(destinationDir, FileUtils.RECURSIVE | FileUtils.SKIP_MISSING);
            destinationDir.mkdirs();
            Files.list(cacheDir.toPath()).filter(path -> !(".git".equals(path.getFileName().toString())))
                    .forEach(path -> {
                        try {
                            Files.move(path, destinationDir.toPath().resolve(path.getFileName()),
                                    StandardCopyOption.ATOMIC_MOVE);
                        } catch (IOException ex) {
                            throw new RuntimeException("Failed to move " + path.getFileName(), ex);
                        }
                    });
        }
        git.close();
    } catch (RepositoryNotFoundException | InvalidRemoteException ex) {
        throw new RuntimeException("Could not find repository");
    } catch (GitAPIException | IOException ex) {
        throw new RuntimeException("Could not checkout data", ex);
    }
}

From source file:fi.otavanopisto.changelogger.Changelogger.java

private static void prependLine(String line, String message) throws IOException, GitAPIException {
    FileRepositoryBuilder frBuilder = new FileRepositoryBuilder();
    Repository repository = frBuilder.setGitDir(new File("./.git")).readEnvironment().build();
    Git git = new Git(repository);

    git.reset().setMode(ResetCommand.ResetType.HARD).call();
    git.clean().call();/*from   ww w  . java2 s.co  m*/
    git.fetch().call();
    git.pull().call();

    File file = new File(CHANGELOG_FILE);
    List<String> lines = FileUtils.readLines(file, Charsets.UTF_8);
    lines.add(0, line);
    FileUtils.writeLines(file, lines);

    git.commit().setMessage(message).setAuthor("Changelogger", "changelogger@otavanopisto.fi").call();

    git.push().call();
}

From source file:fi.otavanopisto.santra.Santra.java

License:Open Source License

private void reload(String botName) throws IOException, GitAPIException {
    log.info("Starting bot reload");
    FileRepositoryBuilder builder = new FileRepositoryBuilder();
    Repository repository = builder.setGitDir(new File(arguments.getBasePath() + "/.git")).readEnvironment()
            .build();//from  w  w  w .  j a v a2  s . c o m
    log.info("Starting repository update");
    Git git = new Git(repository);
    git.reset().setMode(ResetCommand.ResetType.HARD).call();
    log.info("Reset complete");
    git.clean().call();
    log.info("Clean compete");
    git.fetch().call();
    log.info("Fetch complete");
    git.pull().call();
    log.info("Repository update finished");

    initBot(botName);
    log.info("Bot reloaded");
}

From source file:fr.treeptik.cloudunit.utils.GitUtils.java

License:Open Source License

/**
 * this method is associate with listGitTagsOfApplication() method
 * which list all tags with index, this is this index which must pass as parammeter of this method
 *
 * @param application/*from   ww  w .  j av  a2 s  . co  m*/
 * @param indexChosen
 * @param dockerManagerAddress
 * @param containerGitAddress
 * @return
 * @throws InvalidRemoteException
 * @throws TransportException
 * @throws GitAPIException
 * @throws IOException
 */
public static List<String> resetOnChosenGitTag(Application application, int indexChosen,
        String dockerManagerAddress, String containerGitAddress)
        throws InvalidRemoteException, TransportException, GitAPIException, IOException {
    User user = application.getUser();
    String sshPort = application.getServers().get(0).getSshPort();
    String password = user.getPassword();
    String userNameGit = user.getLogin();
    String dockerManagerIP = dockerManagerAddress.substring(0, dockerManagerAddress.length() - 5);
    String remoteRepository = "ssh://" + userNameGit + "@" + dockerManagerIP + ":" + sshPort
            + containerGitAddress;
    File gitworkDir = Files.createTempDirectory("clone").toFile();
    CloneCommand clone = Git.cloneRepository();
    clone.setDirectory(gitworkDir);

    CredentialsProvider credentialsProvider = configCredentialsForGit(userNameGit, password);
    clone.setCredentialsProvider(credentialsProvider);
    clone.setURI(remoteRepository);
    Git git = clone.call();

    ListTagCommand listTagCommand = git.tagList();
    List<Ref> listRefs = listTagCommand.call();

    Ref ref = listRefs.get(indexChosen);

    ResetCommand resetCommand = git.reset();
    resetCommand.setMode(ResetType.HARD);
    resetCommand.setRef(ref.getName());
    resetCommand.call();

    PushCommand pushCommand = git.push();
    pushCommand.setCredentialsProvider(credentialsProvider);
    pushCommand.setForce(true);

    List<PushResult> listPushResults = (List<PushResult>) pushCommand.call();
    List<String> listPushResultsMessages = new ArrayList<>();
    for (PushResult pushResult : listPushResults) {
        listPushResultsMessages.add(pushResult.getMessages());
    }
    FilesUtils.deleteDirectory(gitworkDir);
    return listPushResultsMessages;
}

From source file:fr.xebia.workshop.git.GithubRepositoriesCreator.java

License:Apache License

private void processGitRepositoryHandler(Git git, GithubCreateRepositoryRequest createRequest) {
    try {//from   w w  w .j  a  v a  2s  .co  m
        RevCommit revCommit = git.log().call().iterator().next();

        //call delegate
        createRequest.getGitRepositoryHandler().updateGitRepository(git, createRequest);
        logger.info("Local repository is pushing on remote {}", createRequest.getGithubRepositoryUrl());
        git.push().setCredentialsProvider(createRequest.getCredentialsProvider())
                .setRemote(createRequest.getGithubRepositoryUrl()).call();
        git.reset().setRef(revCommit.getName()).setMode(ResetCommand.ResetType.HARD).call();
    } catch (IOException e) {
        throw new RuntimeException("cannot perform git operation", e);
    } catch (GitAPIException e) {
        throw new RuntimeException("cannot perform git operation", e);
    }
}

From source file:gov.va.isaac.sync.git.SyncServiceGIT.java

License:Apache License

/**
 * @throws AuthenticationException //from w  w w  .  j ava 2  s . c  om
 * @see gov.va.isaac.interfaces.sync.ProfileSyncI#linkAndFetchFromRemote(java.io.File, java.lang.String, java.lang.String, java.lang.String)
 */
@Override
public void linkAndFetchFromRemote(String remoteAddress, String username, String password)
        throws IllegalArgumentException, IOException, AuthenticationException {
    log.info("linkAndFetchFromRemote called - folder: {}, remoteAddress: {}, username: {}", localFolder,
            remoteAddress, username);
    try {
        File gitFolder = new File(localFolder, ".git");
        Repository r = new FileRepository(gitFolder);

        if (!gitFolder.isDirectory()) {
            log.debug("Root folder does not contain a .git subfolder.  Creating new git repository.");
            r.create();
        }

        relinkRemote(remoteAddress, username, password);

        Git git = new Git(r);

        CredentialsProvider cp = new UsernamePasswordCredentialsProvider(username,
                (password == null ? new char[] {} : password.toCharArray()));

        log.debug("Fetching");
        FetchResult fr = git.fetch().setCheckFetchedObjects(true).setCredentialsProvider(cp).call();
        log.debug("Fetch messages: {}", fr.getMessages());

        boolean remoteHasMaster = false;
        Collection<Ref> refs = git.lsRemote().setCredentialsProvider(cp).call();
        for (Ref ref : refs) {
            if ("refs/heads/master".equals(ref.getName())) {
                remoteHasMaster = true;
                log.debug("Remote already has 'heads/master'");
                break;
            }
        }

        if (remoteHasMaster) {
            //we need to fetch and (maybe) merge - get onto origin/master.

            log.debug("Fetching from remote");
            String fetchResult = git.fetch().setCredentialsProvider(cp).call().getMessages();
            log.debug("Fetch Result: {}", fetchResult);

            log.debug("Resetting to origin/master");
            git.reset().setMode(ResetType.MIXED).setRef("origin/master").call();

            //Get the files from master that we didn't have in our working folder
            log.debug("Checking out missing files from origin/master");
            for (String missing : git.status().call().getMissing()) {
                log.debug("Checkout {}", missing);
                git.checkout().addPath(missing).call();
            }

            for (String newFile : makeInitialFilesAsNecessary(localFolder)) {
                log.debug("Adding and committing {}", newFile);
                git.add().addFilepattern(newFile).call();
                git.commit().setMessage("Adding " + newFile).setAuthor(username, "42").call();

                for (PushResult pr : git.push().setCredentialsProvider(cp).call()) {
                    log.debug("Push Message: {}", pr.getMessages());
                }
            }
        } else {
            //just push
            //make sure we have something to push
            for (String newFile : makeInitialFilesAsNecessary(localFolder)) {
                log.debug("Adding and committing {}", newFile);
                git.add().addFilepattern(newFile).call();
                git.commit().setMessage("Adding readme file").setAuthor(username, "42").call();
            }

            log.debug("Pushing repository");
            for (PushResult pr : git.push().setCredentialsProvider(cp).call()) {
                log.debug("Push Result: {}", pr.getMessages());
            }
        }

        log.info("linkAndFetchFromRemote Complete.  Current status: " + statusToString(git.status().call()));
    } catch (TransportException te) {
        if (te.getMessage().contains("Auth fail")) {
            log.info("Auth fail", te);
            throw new AuthenticationException("Auth fail");
        } else {
            log.error("Unexpected", te);
            throw new IOException("Internal error", te);
        }
    } catch (GitAPIException e) {
        log.error("Unexpected", e);
        throw new IOException("Internal error", e);
    }
}

From source file:io.fabric8.forge.rest.main.ProjectFileSystem.java

License:Apache License

protected void doPull(File gitFolder, CredentialsProvider cp, String branch) {
    try {// w w w .j  a va 2  s  .c o m
        FileRepositoryBuilder builder = new FileRepositoryBuilder();
        Repository repository = builder.setGitDir(gitFolder).readEnvironment() // scan environment GIT_* variables
                .findGitDir() // scan up the file system tree
                .build();

        Git git = new Git(repository);

        File projectFolder = repository.getDirectory();

        StoredConfig config = repository.getConfig();
        String url = config.getString("remote", remote, "url");
        if (Strings.isNullOrBlank(url)) {
            LOG.warn("No remote repository url for " + branch + " defined for the git repository at "
                    + projectFolder.getCanonicalPath() + " so cannot pull");
            //return;
        }
        String mergeUrl = config.getString("branch", branch, "merge");
        if (Strings.isNullOrBlank(mergeUrl)) {
            LOG.warn("No merge spec for branch." + branch + ".merge in the git repository at "
                    + projectFolder.getCanonicalPath() + " so not doing a pull");
            //return;
        }

        // lets trash any failed changes
        LOG.info("Resetting the repo");
        git.reset().setMode(ResetCommand.ResetType.HARD).call();

        LOG.info("Performing a pull in git repository " + projectFolder.getCanonicalPath() + " on remote URL: "
                + url);
        git.pull().setCredentialsProvider(cp).setRebase(true).call();
    } catch (Throwable e) {
        LOG.error("Failed to pull from the remote git repo with credentials " + cp + " due: " + e.getMessage()
                + ". This exception is ignored.", e);
    }
}

From source file:io.fabric8.git.zkbridge.Bridge.java

License:Apache License

private void updateLocal(Git git, CuratorFramework zookeeper, CredentialsProvider credentialsProvider)
        throws Exception {
    String remoteName = "origin";

    try {//from  w  w w  .  ja v  a2  s.  c  o  m
        git.fetch().setCredentialsProvider(credentialsProvider).setRemote(remoteName).call();
    } catch (Exception e) {
        // Ignore fetch exceptions
        return;
    }

    // Get local and remote branches
    Map<String, Ref> localBranches = new HashMap<String, Ref>();
    Map<String, Ref> remoteBranches = new HashMap<String, Ref>();
    Set<String> gitVersions = new HashSet<String>();
    for (Ref ref : git.branchList().setListMode(ListBranchCommand.ListMode.ALL).call()) {
        if (ref.getName().startsWith("refs/remotes/" + remoteName + "/")) {
            String name = ref.getName().substring(("refs/remotes/" + remoteName + "/").length());
            if (!"master".equals(name) && !name.endsWith("-tmp")) {
                remoteBranches.put(name, ref);
                gitVersions.add(name);
            }
        } else if (ref.getName().startsWith("refs/heads/")) {
            String name = ref.getName().substring(("refs/heads/").length());
            if (!name.equals("master") && !name.endsWith("-tmp")) {
                localBranches.put(name, ref);
                gitVersions.add(name);
            }
        }
    }

    // Check git commmits
    for (String version : gitVersions) {
        // Delete unneeded local branches
        if (!remoteBranches.containsKey(version)) {
            git.branchDelete().setBranchNames(localBranches.get(version).getName()).setForce(true).call();
        }
        // Create new local branches
        else if (!localBranches.containsKey(version)) {
            git.branchCreate().setName(version).call();
            git.reset().setMode(ResetCommand.ResetType.HARD).setRef(remoteBranches.get(version).getName())
                    .call();
        } else {
            String localCommit = localBranches.get(version).getObjectId().getName();
            String remoteCommit = remoteBranches.get(version).getObjectId().getName();
            if (!localCommit.equals(remoteCommit)) {
                git.clean().setCleanDirectories(true).call();
                git.checkout().setName("HEAD").setForce(true).call();
                git.checkout().setName(version).setForce(true).call();
                MergeResult result = git.merge().setStrategy(MergeStrategy.THEIRS)
                        .include(remoteBranches.get(version).getObjectId()).call();
                // TODO: handle conflicts
            }
        }
    }
}

From source file:io.fabric8.git.zkbridge.Bridge.java

License:Apache License

private static void update(Git git, CuratorFramework zookeeper, CredentialsProvider credentialsProvider)
        throws Exception {
    String remoteName = "origin";

    boolean remoteAvailable = false;
    try {// w  ww  . j av  a2 s . c o  m
        git.fetch().setCredentialsProvider(credentialsProvider).setRemote(remoteName).call();
        remoteAvailable = true;
    } catch (Exception e) {
        // Ignore fetch exceptions
        if (LOGGER.isTraceEnabled()) {
            LOGGER.trace("Unable to fetch master", e);
        } else if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("Unable to fetch master: " + e.getClass().getName() + ": " + e.getMessage());
        }
    }

    // Handle versions in git and not in zookeeper
    Map<String, Ref> localBranches = new HashMap<String, Ref>();
    Map<String, Ref> remoteBranches = new HashMap<String, Ref>();
    Set<String> gitVersions = new HashSet<String>();
    for (Ref ref : git.branchList().setListMode(ListBranchCommand.ListMode.ALL).call()) {
        if (ref.getName().startsWith("refs/remotes/" + remoteName + "/")) {
            String name = ref.getName().substring(("refs/remotes/" + remoteName + "/").length());
            if (!"master".equals(name) && !name.endsWith("-tmp")) {
                remoteBranches.put(name, ref);
                gitVersions.add(name);
            }
        } else if (ref.getName().startsWith("refs/heads/")) {
            String name = ref.getName().substring(("refs/heads/").length());
            if (!name.equals("master") && !name.endsWith("-tmp")) {
                localBranches.put(name, ref);
                gitVersions.add(name);
            }
        }
    }
    List<String> zkVersions = getChildren(zookeeper, ZkPath.CONFIG_VERSIONS.getPath());
    createDefault(zookeeper, "/fabric/configs/git", null);
    Properties versionsMetadata = loadProps(zookeeper, "/fabric/configs/git");

    boolean allDone = true;
    // Check no modifs in zookeeper
    String lastModified = Long.toString(lastModified(zookeeper, ZkPath.CONFIG_VERSIONS.getPath()));
    if (!lastModified.equals(versionsMetadata.get("zk-lastmodified"))) {
        allDone = false;
    }
    // Check the versions in zk and git are the same
    if (zkVersions.size() != gitVersions.size() || !zkVersions.containsAll(gitVersions)) {
        allDone = false;
    }
    // Check all local and remote branches exists
    if (gitVersions.size() != localBranches.size() || !localBranches.keySet().containsAll(gitVersions)) {
        allDone = false;
    }
    // If remote is available, check that all remote branches exist
    if (remoteAvailable && !remoteBranches.keySet().containsAll(gitVersions)) {
        allDone = false;
    }
    // Check git commmits
    if (allDone) {
        for (String version : zkVersions) {
            String zkCommit = versionsMetadata.get(version);
            String localCommit = localBranches.get(version).getObjectId().getName();
            String remoteCommit = remoteAvailable ? remoteBranches.get(version).getObjectId().getName() : null;
            if (!localCommit.equals(zkCommit) || remoteCommit != null && !localCommit.equals(remoteCommit)) {
                allDone = false;
                break;
            }
        }
    }
    if (allDone) {
        return;
    }

    // ZooKeeper -> Git changes
    for (String version : zkVersions) {
        String zkNode = ZkPath.CONFIG_VERSION.getPath(version);

        // Checkout updated version
        List<Ref> allBranches = git.branchList().setListMode(ListBranchCommand.ListMode.ALL).call();
        Ref local = null;
        Ref remote = null;
        Ref tmp = null;
        for (Ref ref : allBranches) {
            if (ref.getName().equals("refs/remotes/" + remoteName + "/" + version)) {
                remote = ref;
            } else if (ref.getName().equals("refs/heads/" + version)) {
                local = ref;
            } else if (ref.getName().equals("refs/heads/" + version + "-tmp")) {
                tmp = ref;
            }
        }
        if (local == null) {
            git.branchCreate().setName(version).call();
        }
        if (tmp == null) {
            git.branchCreate().setName(version + "-tmp").call();
        }
        git.clean().setCleanDirectories(true).call();
        git.checkout().setName("HEAD").setForce(true).call();
        git.checkout().setName(version).setForce(true).call();
        if (remoteAvailable && remote != null) {
            MergeResult result = git.merge().setStrategy(MergeStrategy.THEIRS).include(remote.getObjectId())
                    .call();
            // TODO: check merge conflicts
        }
        git.checkout().setName(version + "-tmp").setForce(true).call();
        String gitCommit = versionsMetadata.get(version);
        if (gitCommit != null) {
            try {
                git.reset().setMode(ResetCommand.ResetType.HARD).setRef(gitCommit).call();
            } catch (Exception e) {
                // Ignore, we did our best
                if (LOGGER.isTraceEnabled()) {
                    LOGGER.trace("Unable to reset branch to commit", e);
                } else if (LOGGER.isDebugEnabled()) {
                    LOGGER.debug("Unable to reset branch to commit " + gitCommit + ": " + e.getClass().getName()
                            + ": " + e.getMessage());
                }
            }
        }

        // Apply changes to git
        syncVersionFromZkToGit(git, zookeeper, zkNode);

        if (git.status().call().isClean()) {
            git.checkout().setName(version).setForce(true).call();
        } else {
            ObjectId rev = git.commit().setMessage("Merge zookeeper updates in version " + version).call()
                    .getId();
            git.checkout().setName(version).setForce(true).call();
            MergeResult result = git.merge().setStrategy(MergeStrategy.OURS).include(rev).call();
            // TODO: check merge conflicts
        }
        if (remoteAvailable) {
            git.push().setCredentialsProvider(credentialsProvider).setRefSpecs(new RefSpec(version)).call();
        }

        // Apply changes to zookeeper
        syncVersionFromGitToZk(git, zookeeper, zkNode);

        versionsMetadata.put(version, git.getRepository().getRef("HEAD").getObjectId().getName());
    }
    // Iterate through known git versions
    for (String version : gitVersions) {
        String state = versionsMetadata.get(version);
        if (zkVersions.contains(version)) {
            continue;
        }
        // The version is not known to zookeeper, so create it
        if (state == null) {
            if (localBranches.containsKey(version)) {
                if (remoteAvailable) {
                    git.push().setRefSpecs(new RefSpec(version)).call();
                }
            } else {
                git.branchCreate().setName(version).call();
                git.reset().setMode(ResetCommand.ResetType.HARD).setRef(remoteBranches.get(version).getName())
                        .call();
            }
            git.checkout().setName(version).setForce(true).call();
            // Sync zookeeper
            String zkNode = ZkPath.CONFIG_VERSION.getPath(version);
            create(zookeeper, zkNode);
            create(zookeeper, ZkPath.CONFIG_VERSIONS_PROFILES.getPath(version));
            create(zookeeper, ZkPath.CONFIG_VERSIONS_CONTAINERS.getPath(version));
            syncVersionFromGitToZk(git, zookeeper, zkNode);
            // Flag version as active
            versionsMetadata.put(version, git.getRepository().getRef("HEAD").getObjectId().getName());
        }
        // The version has been deleted from zookeeper so delete it in git
        else {
            git.checkout().setName("master").setForce(true).call();
            git.branchDelete().setBranchNames(version, version + "-tmp").setForce(true).call();
            git.push().setRefSpecs(new RefSpec(version + ":")).call();
            versionsMetadata.remove(version);
        }
    }
    versionsMetadata.put("zk-lastmodified",
            Long.toString(lastModified(zookeeper, ZkPath.CONFIG_VERSIONS.getPath())));
    setPropertiesAsMap(zookeeper, "/fabric/configs/git", versionsMetadata);
}