示例#1
1
  private void writeNewVersion(Document document) throws IOException, GitAPIException {
    final File docDir = getDirForDoc(document.getId());
    Git git = null;
    if (!docDir.exists()) {
      docDir.mkdirs();
      git = new InitCommand().setDirectory(docDir).call();
    } else {
      git = Git.open(docDir);
      completeUndo(git);
    }

    File outputFile = new File(docDir, "document.xml");
    FileOutputStream fos = new FileOutputStream(outputFile);
    try {
      document.serialize(fos);
    } catch (XMLStreamException e) {
      throw new RuntimeException(e);
    } finally {
      fos.close();
    }
    git.add().addFilepattern("document.xml").call();
    git.commit()
        .setCommitter("transmog", "*****@*****.**")
        .setMessage("Updated through application.")
        .call();
  }
  @Test
  public void testConflictsFromOtherPush() throws Exception {
    // now Repository 2 update the file and push
    File file1 = new File(workdir2, "file.txt");
    repositoryUtil.appendFileContent(file1, "-->from Repository 2");
    Git git = new Git(repository2);
    git.add().addFilepattern("file.txt").call();
    git.commit().setMessage("Second Commit").call();

    URIish remote = new URIish("file:///" + repository1.getDirectory().toString());
    // now push the Repository 2 into the Repository 1
    RefSpec rs = new RefSpec();
    rs = rs.setSourceDestination("refs/heads/master", "refs/heads/master");
    PushOperation po =
        new PushOperation(repository2, remote.toString(), Arrays.asList(rs), false, 0);
    po.execute();
    System.out.println(po.toString());

    // Now Repository 3 update the file and push
    File file2 = new File(workdir3, "file.txt");
    repositoryUtil.appendFileContent(file2, "-->from Repository 3");
    git = new Git(repository3);
    git.add().addFilepattern("file.txt").call();
    git.commit().setMessage("Third Commit").call();

    // now push the Repository 3 into the Repository 1
    rs = new RefSpec();
    rs = rs.setSourceDestination("refs/heads/master", "refs/heads/master");
    //		rs=rs.setForceUpdate(true);
    po = new PushOperation(repository3, remote.toString(), Arrays.asList(rs), false, 0);
    po.execute();
    System.out.println(po.toString());
  }
  @Test
  public void testLinesAllDeletedShortenedWalk() throws Exception {
    Git git = new Git(db);

    String[] content1 = new String[] {"first", "second", "third"};

    writeTrashFile("file.txt", join(content1));
    git.add().addFilepattern("file.txt").call();
    git.commit().setMessage("create file").call();

    String[] content2 = new String[] {""};

    writeTrashFile("file.txt", join(content2));
    git.add().addFilepattern("file.txt").call();
    git.commit().setMessage("create file").call();

    writeTrashFile("file.txt", join(content1));
    git.add().addFilepattern("file.txt").call();
    RevCommit c3 = git.commit().setMessage("create file").call();

    BlameGenerator generator = new BlameGenerator(db, "file.txt");
    try {
      generator.push(null, db.resolve(Constants.HEAD));
      assertEquals(3, generator.getResultContents().size());

      assertTrue(generator.next());
      assertEquals(c3, generator.getSourceCommit());
      assertEquals(0, generator.getResultStart());
      assertEquals(3, generator.getResultEnd());

      assertFalse(generator.next());
    } finally {
      generator.release();
    }
  }
  @Before
  public void setUp() throws Exception {
    sfb = new ZKServerFactoryBean();
    delete(sfb.getDataDir());
    delete(sfb.getDataLogDir());
    sfb.afterPropertiesSet();

    CuratorFrameworkFactory.Builder builder =
        CuratorFrameworkFactory.builder()
            .connectString("localhost:" + sfb.getClientPortAddress().getPort())
            .retryPolicy(new RetryOneTime(1000))
            .connectionTimeoutMs(360000);

    curator = builder.build();
    curator.start();
    curator.getZookeeperClient().blockUntilConnectedOrTimedOut();

    // setup a local and remote git repo
    basedir = System.getProperty("basedir", ".");
    File root = new File(basedir + "/target/git").getCanonicalFile();
    delete(root);

    new File(root, "remote").mkdirs();
    remote = Git.init().setDirectory(new File(root, "remote")).call();
    remote.commit().setMessage("First Commit").setCommitter("fabric", "user@fabric").call();
    String remoteUrl = "file://" + new File(root, "remote").getCanonicalPath();

    new File(root, "local").mkdirs();
    git = Git.init().setDirectory(new File(root, "local")).call();
    git.commit().setMessage("First Commit").setCommitter("fabric", "user@fabric").call();
    StoredConfig config = git.getRepository().getConfig();
    config.setString("remote", "origin", "url", remoteUrl);
    config.setString("remote", "origin", "fetch", "+refs/heads/*:refs/remotes/origin/*");
    config.save();

    DefaultRuntimeProperties sysprops = new DefaultRuntimeProperties();
    sysprops.setProperty(SystemProperties.KARAF_DATA, "target/data");
    FabricGitServiceImpl gitService = new FabricGitServiceImpl();
    gitService.bindRuntimeProperties(sysprops);
    gitService.activate();
    gitService.setGitForTesting(git);

    DataStoreTemplateRegistry registrationHandler = new DataStoreTemplateRegistry();
    registrationHandler.activateComponent();

    dataStore = new CachingGitDataStore();
    dataStore.bindCurator(curator);
    dataStore.bindGitService(gitService);
    dataStore.bindRegistrationHandler(registrationHandler);
    dataStore.bindRuntimeProperties(sysprops);
    dataStore.bindConfigurer(
        new Configurer() {
          @Override
          public <T> void configure(Map<String, ?> configuration, T target) throws Exception {}
        });
    Map<String, String> datastoreProperties = new HashMap<String, String>();
    datastoreProperties.put(GitDataStore.GIT_REMOTE_URL, remoteUrl);
    dataStore.activate(datastoreProperties);
  }
示例#5
0
  @Test
  public void testStageState_mergeAndReset_bug() throws Exception {
    try (Git git = new Git(db)) {
      writeTrashFile("a", "content");
      git.add().addFilepattern("a").call();
      RevCommit initialCommit = git.commit().setMessage("initial commit").call();

      // create branch and add a new file
      final String branchName = Constants.R_HEADS + "branch";
      createBranch(initialCommit, branchName);
      checkoutBranch(branchName);
      writeTrashFile("b", "second file content - branch");
      git.add().addFilepattern("b").call();
      RevCommit branchCommit = git.commit().setMessage("branch commit").call();

      // checkout master and add the same new file
      checkoutBranch(Constants.R_HEADS + Constants.MASTER);
      writeTrashFile("b", "second file content - master");
      git.add().addFilepattern("b").call();
      git.commit().setMessage("master commit").call();

      // try and merge
      MergeResult result = git.merge().include(branchCommit).call();
      assertEquals(MergeStatus.CONFLICTING, result.getMergeStatus());

      FileTreeIterator iterator = new FileTreeIterator(db);
      IndexDiff diff = new IndexDiff(db, Constants.HEAD, iterator);
      diff.diff();

      assertTrue(diff.getChanged().isEmpty());
      assertTrue(diff.getAdded().isEmpty());
      assertTrue(diff.getRemoved().isEmpty());
      assertTrue(diff.getMissing().isEmpty());
      assertTrue(diff.getModified().isEmpty());
      assertEquals(1, diff.getConflicting().size());
      assertTrue(diff.getConflicting().contains("b"));
      assertEquals(StageState.BOTH_ADDED, diff.getConflictingStageStates().get("b"));
      assertTrue(diff.getUntrackedFolders().isEmpty());

      // reset file b to its master state without altering the index
      writeTrashFile("b", "second file content - master");

      // we should have the same result
      iterator = new FileTreeIterator(db);
      diff = new IndexDiff(db, Constants.HEAD, iterator);
      diff.diff();

      assertTrue(diff.getChanged().isEmpty());
      assertTrue(diff.getAdded().isEmpty());
      assertTrue(diff.getRemoved().isEmpty());
      assertTrue(diff.getMissing().isEmpty());
      assertTrue(diff.getModified().isEmpty());
      assertEquals(1, diff.getConflicting().size());
      assertTrue(diff.getConflicting().contains("b"));
      assertEquals(StageState.BOTH_ADDED, diff.getConflictingStageStates().get("b"));
      assertTrue(diff.getUntrackedFolders().isEmpty());
    }
  }
  @Before
  public void setUp() throws Exception {

    IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();

    FileUtils.mkdir(new File(root.getLocation().toFile(), "Sub"), true);
    gitDir = new File(new File(root.getLocation().toFile(), "Sub"), Constants.DOT_GIT);

    repository = FileRepositoryBuilder.create(gitDir);
    repository.create();

    project = root.getProject(TEST_PROJECT);
    project.create(null);
    project.open(null);
    IProjectDescription description = project.getDescription();
    description.setLocation(root.getLocation().append(TEST_PROJECT_LOC));
    project.move(description, IResource.FORCE, null);

    project2 = root.getProject(TEST_PROJECT2);
    project2.create(null);
    project2.open(null);
    gitDir2 = new File(project2.getLocation().toFile().getAbsoluteFile(), Constants.DOT_GIT);
    repository2 = FileRepositoryBuilder.create(gitDir2);
    repository2.create();

    RepositoryMapping mapping = RepositoryMapping.create(project, gitDir);
    RepositoryMapping mapping2 = RepositoryMapping.create(project2, gitDir2);

    GitProjectData projectData = new GitProjectData(project);
    GitProjectData projectData2 = new GitProjectData(project2);
    projectData.setRepositoryMappings(Collections.singletonList(mapping));
    projectData.store();
    projectData2.setRepositoryMappings(Collections.singletonList(mapping2));
    projectData2.store();
    GitProjectData.add(project, projectData);
    GitProjectData.add(project2, projectData2);

    RepositoryProvider.map(project, GitProvider.class.getName());
    RepositoryProvider.map(project2, GitProvider.class.getName());

    JGitTestUtil.write(
        new File(repository.getWorkTree(), TEST_PROJECT + "/" + TEST_FILE), "Some data");
    JGitTestUtil.write(new File(repository2.getWorkTree(), TEST_FILE2), "Some other data");
    project.refreshLocal(IResource.DEPTH_INFINITE, null);
    project2.refreshLocal(IResource.DEPTH_INFINITE, null);
    git = new Git(repository);
    git.add().addFilepattern(".").call();
    git.commit().setMessage("Initial commit").call();

    git = new Git(repository2);
    git.add().addFilepattern(".").call();
    git.commit().setMessage("Initial commit").call();
    git.branchRename().setNewName("main").call();
  }
示例#7
0
  @Test
  public void testPushToNonBareRepository() throws Exception {
    CloneCommand clone = Git.cloneRepository();
    clone.setURI(MessageFormat.format("{0}/git/working/jgit", url));
    clone.setDirectory(jgit2Folder);
    clone.setBare(false);
    clone.setCloneAllBranches(true);
    clone.setCredentialsProvider(new UsernamePasswordCredentialsProvider(account, password));
    close(clone.call());
    assertTrue(true);

    Git git = Git.open(jgit2Folder);
    File file = new File(jgit2Folder, "NONBARE");
    OutputStreamWriter os =
        new OutputStreamWriter(new FileOutputStream(file, true), Constants.CHARSET);
    BufferedWriter w = new BufferedWriter(os);
    w.write("// " + new Date().toString() + "\n");
    w.close();
    git.add().addFilepattern(file.getName()).call();
    git.commit().setMessage("test commit followed by push to non-bare repository").call();
    try {
      git.push().setPushAll().call();
      assertTrue(false);
    } catch (Exception e) {
      assertTrue(e.getCause().getMessage().contains("git-receive-pack not permitted"));
    }
    close(git);
  }
示例#8
0
  public void renameRole(String roleName, String newRoleName, User currentUser) throws IOException {
    Assert.hasLength(roleName);
    Assert.hasLength(newRoleName);
    Assert.notNull(currentUser);
    // check that role exists by trying to load it
    getRole(roleName);
    // check that new role does not exist by trying to load it
    try {
      getRole(newRoleName);
      throw new IllegalArgumentException("role already exists: " + newRoleName); // $NON-NLS-1$
    } catch (RoleNotFoundException e) {
      // okay
    }

    log.info("renaming role: {} -> {}", roleName, newRoleName); // $NON-NLS-1$

    ILockedRepository repo = null;
    try {
      repo = globalRepositoryManager.getProjectCentralRepository(REPOSITORY_NAME, false);

      File workingDir = RepositoryUtil.getWorkingDir(repo.r());

      File file = new File(workingDir, roleName + ROLE_SUFFIX);
      File newFile = new File(workingDir, newRoleName + ROLE_SUFFIX);
      FileUtils.copyFile(file, newFile);
      Git git = Git.wrap(repo.r());
      git.rm().addFilepattern(roleName + ROLE_SUFFIX).call();
      git.add().addFilepattern(newRoleName + ROLE_SUFFIX).call();

      List<String> users = listUsers(repo);
      users.add(ANONYMOUS_USER_LOGIN_NAME);
      for (String user : users) {
        List<RoleGrantedAuthority> authorities = getUserAuthorities(user, repo);
        Set<RoleGrantedAuthority> newAuthorities = Sets.newHashSet();
        for (Iterator<RoleGrantedAuthority> iter = authorities.iterator(); iter.hasNext(); ) {
          RoleGrantedAuthority rga = iter.next();
          if (rga.getRoleName().equals(roleName)) {
            RoleGrantedAuthority newRga = new RoleGrantedAuthority(rga.getTarget(), newRoleName);
            newAuthorities.add(newRga);
            iter.remove();
          }
        }
        if (!newAuthorities.isEmpty()) {
          authorities.addAll(newAuthorities);
          saveUserAuthorities(user, Sets.newHashSet(authorities), repo, currentUser, false);
        }
      }

      PersonIdent ident = new PersonIdent(currentUser.getLoginName(), currentUser.getEmail());
      git.commit()
          .setAuthor(ident)
          .setCommitter(ident)
          .setMessage("rename role " + roleName + " to " + newRoleName) // $NON-NLS-1$ //$NON-NLS-2$
          .call();
    } catch (GitAPIException e) {
      throw new IOException(e);
    } finally {
      Util.closeQuietly(repo);
    }
  }
示例#9
0
 protected RevCommit doRename(
     Git git,
     File rootDir,
     String branch,
     String oldPath,
     String newPath,
     String commitMessage,
     PersonIdent personIdent)
     throws Exception {
   File file = getFile(rootDir, oldPath);
   File newFile = getFile(rootDir, newPath);
   if (file.exists()) {
     File parentFile = newFile.getParentFile();
     parentFile.mkdirs();
     if (!parentFile.exists()) {
       throw new IOException(
           "Could not create directory "
               + parentFile
               + " when trying to move "
               + file
               + " to "
               + newFile
               + ". Maybe a file permission issue?");
     }
     file.renameTo(newFile);
     String filePattern = getFilePattern(newPath);
     git.add().addFilepattern(filePattern).call();
     CommitCommand commit =
         git.commit().setAll(true).setAuthor(personIdent).setMessage(commitMessage);
     return commitThenPush(git, branch, commit);
   } else {
     return null;
   }
 }
示例#10
0
  @Test
  public void finishHotfixMasterIsTagged() throws Exception {
    Git git = RepoUtil.createRepositoryWithMasterAndTag(newDir());
    JGitFlowInitCommand initCommand = new JGitFlowInitCommand();
    JGitFlow flow = initCommand.setDirectory(git.getRepository().getWorkTree()).call();

    flow.hotfixStart("1.1").call();

    // Make sure we move away from master on a hotfix branch
    // This is important to validate JGITFFLOW-14

    // create a new commit
    File junkFile = new File(git.getRepository().getWorkTree(), "junk.txt");
    FileUtils.writeStringToFile(junkFile, "I am junk");
    git.add().addFilepattern(junkFile.getName()).call();
    git.commit().setMessage("committing junk file").call();

    flow.hotfixFinish("1.1").setNoTag(false).call();

    // we should be on develop branch
    assertEquals(flow.getDevelopBranchName(), git.getRepository().getBranch());

    // There should be a tag reference
    Ref hotfixTagRef = git.getRepository().getTags().get(flow.getVersionTagPrefix() + "1.1");

    assertNotNull(hotfixTagRef);

    RevTag hotfixTag = new RevWalk(git.getRepository()).parseTag(hotfixTagRef.getObjectId());

    assertNotNull(hotfixTag);

    // Check that latest tag has moved
    assertFalse(getTaggedCommit(git, "1.1").equals(getTaggedCommit(git, "1.0")));
  }
示例#11
0
  /**
   * Saves a user.
   *
   * @param user the user to save
   * @param currentUser the user performing the save operation
   */
  public void saveUser(User user, User currentUser) throws IOException {
    Assert.notNull(user);
    Assert.notNull(currentUser);

    ILockedRepository repo = null;
    try {
      repo = globalRepositoryManager.getProjectCentralRepository(REPOSITORY_NAME, false);
      Map<String, Object> userMap = new HashMap<String, Object>();
      userMap.put("loginName", user.getLoginName()); // $NON-NLS-1$
      userMap.put("password", user.getPassword()); // $NON-NLS-1$
      userMap.put("email", user.getEmail()); // $NON-NLS-1$
      userMap.put("disabled", Boolean.valueOf(user.isDisabled())); // $NON-NLS-1$
      if (!user.getOpenIds().isEmpty()) {
        userMap.put("openIds", user.getOpenIds()); // $NON-NLS-1$
      }

      Gson gson = new GsonBuilder().enableComplexMapKeySerialization().create();
      String json = gson.toJson(userMap);
      File workingDir = RepositoryUtil.getWorkingDir(repo.r());
      File workingFile = new File(workingDir, user.getLoginName() + USER_SUFFIX);
      FileUtils.write(workingFile, json, Charsets.UTF_8);

      Git git = Git.wrap(repo.r());
      git.add().addFilepattern(user.getLoginName() + USER_SUFFIX).call();
      PersonIdent ident = new PersonIdent(currentUser.getLoginName(), currentUser.getEmail());
      git.commit().setAuthor(ident).setCommitter(ident).setMessage(user.getLoginName()).call();
    } catch (GitAPIException e) {
      throw new IOException(e);
    } finally {
      Util.closeQuietly(repo);
    }
  }
示例#12
0
  @Test(expected = BranchOutOfDateException.class)
  public void finishHotfixMasterBehindRemoteWithFetch() throws Exception {
    Git git = null;
    Git remoteGit = null;
    remoteGit = RepoUtil.createRepositoryWithMasterAndTag(newDir());

    git =
        Git.cloneRepository()
            .setDirectory(newDir())
            .setURI("file://" + remoteGit.getRepository().getWorkTree().getPath())
            .call();

    JGitFlowInitCommand initCommand = new JGitFlowInitCommand();
    JGitFlow flow = initCommand.setDirectory(git.getRepository().getWorkTree()).call();

    flow.hotfixStart("1.1").call();

    // do a commit to the remote develop branch
    remoteGit.checkout().setName(flow.getDevelopBranchName());
    File junkFile = new File(remoteGit.getRepository().getWorkTree(), "junk.txt");
    FileUtils.writeStringToFile(junkFile, "I am junk");
    remoteGit.add().addFilepattern(junkFile.getName()).call();
    remoteGit.commit().setMessage("adding junk file").call();

    flow.hotfixFinish("1.1").setFetch(true).call();
  }
示例#13
0
  @Test
  public void testAutoCRLFInput() throws Exception {
    try (Git git = new Git(db)) {
      FileBasedConfig config = db.getConfig();

      // Make sure core.autocrlf is false before adding
      config.setEnum(
          ConfigConstants.CONFIG_CORE_SECTION,
          null,
          ConfigConstants.CONFIG_KEY_AUTOCRLF,
          AutoCRLF.FALSE);
      config.save();

      // File is already in repository with CRLF
      writeTrashFile("crlf.txt", "this\r\ncontains\r\ncrlf\r\n");
      git.add().addFilepattern("crlf.txt").call();
      git.commit().setMessage("Add crlf.txt").call();

      // Now set core.autocrlf to input
      config.setEnum(
          ConfigConstants.CONFIG_CORE_SECTION,
          null,
          ConfigConstants.CONFIG_KEY_AUTOCRLF,
          AutoCRLF.INPUT);
      config.save();

      FileTreeIterator iterator = new FileTreeIterator(db);
      IndexDiff diff = new IndexDiff(db, Constants.HEAD, iterator);
      diff.diff();

      assertTrue(
          "Expected no modified files, but there were: " + diff.getModified(),
          diff.getModified().isEmpty());
    }
  }
示例#14
0
  /**
   * Saves a role.
   *
   * @param role the role to save
   * @param currentUser the user performing the save operation
   */
  public void saveRole(Role role, User currentUser) throws IOException {
    Assert.notNull(role);
    Assert.notNull(currentUser);

    ILockedRepository repo = null;
    try {
      repo = globalRepositoryManager.getProjectCentralRepository(REPOSITORY_NAME, false);

      Map<String, Object> roleMap = new HashMap<String, Object>();
      roleMap.put("name", role.getName()); // $NON-NLS-1$
      Set<String> permissions = Sets.newHashSet();
      for (Permission permission : role.getPermissions()) {
        permissions.add(permission.name());
      }
      roleMap.put("permissions", permissions); // $NON-NLS-1$

      Gson gson = new GsonBuilder().enableComplexMapKeySerialization().create();
      String json = gson.toJson(roleMap);
      File workingDir = RepositoryUtil.getWorkingDir(repo.r());
      File workingFile = new File(workingDir, role.getName() + ROLE_SUFFIX);
      FileUtils.write(workingFile, json, Charsets.UTF_8);

      Git git = Git.wrap(repo.r());
      git.add().addFilepattern(role.getName() + ROLE_SUFFIX).call();
      PersonIdent ident = new PersonIdent(currentUser.getLoginName(), currentUser.getEmail());
      git.commit().setAuthor(ident).setCommitter(ident).setMessage(role.getName()).call();
    } catch (GitAPIException e) {
      throw new IOException(e);
    } finally {
      Util.closeQuietly(repo);
    }
  }
示例#15
0
  private void saveUserAuthorities(
      String loginName,
      Set<RoleGrantedAuthority> authorities,
      ILockedRepository repo,
      User currentUser,
      boolean commit)
      throws IOException, GitAPIException {

    Map<String, Set<String>> authoritiesMap = new HashMap<String, Set<String>>();
    for (RoleGrantedAuthority rga : authorities) {
      GrantedAuthorityTarget target = rga.getTarget();
      String targetStr = target.getType().name() + ":" + target.getTargetId(); // $NON-NLS-1$
      Set<String> roleNames = authoritiesMap.get(targetStr);
      if (roleNames == null) {
        roleNames = Sets.newHashSet();
        authoritiesMap.put(targetStr, roleNames);
      }
      roleNames.add(rga.getRoleName());
    }

    Gson gson = new GsonBuilder().enableComplexMapKeySerialization().create();
    String json = gson.toJson(authoritiesMap);
    File workingDir = RepositoryUtil.getWorkingDir(repo.r());
    File workingFile = new File(workingDir, loginName + AUTHORITIES_SUFFIX);
    FileUtils.write(workingFile, json, Charsets.UTF_8);

    Git git = Git.wrap(repo.r());
    git.add().addFilepattern(loginName + AUTHORITIES_SUFFIX).call();
    if (commit) {
      PersonIdent ident = new PersonIdent(currentUser.getLoginName(), currentUser.getEmail());
      git.commit().setAuthor(ident).setCommitter(ident).setMessage(loginName).call();
    }
  }
 private void doCommitPush(Git git, String message) throws GitAPIException {
   git.commit()
       .setAuthor(getAuthorName(), "*****@*****.**")
       .setCommitter("opal", "*****@*****.**")
       .setMessage(message)
       .call();
   git.push().setPushAll().setRemote("origin").call();
 }
示例#17
0
  @Test
  public void testStageState_simulated_bug() throws Exception {
    try (Git git = new Git(db)) {
      writeTrashFile("a", "content");
      git.add().addFilepattern("a").call();
      RevCommit initialCommit = git.commit().setMessage("initial commit").call();

      // create branch and add a new file
      final String branchName = Constants.R_HEADS + "branch";
      createBranch(initialCommit, branchName);
      checkoutBranch(branchName);
      writeTrashFile("b", "second file content - branch");
      git.add().addFilepattern("b").call();
      git.commit().setMessage("branch commit").call();

      // checkout master and add the same new file
      checkoutBranch(Constants.R_HEADS + Constants.MASTER);
      writeTrashFile("b", "second file content - master");
      git.add().addFilepattern("b").call();
      git.commit().setMessage("master commit").call();

      // Simulate a failed merge of branch into master
      DirCacheBuilder builder = db.lockDirCache().builder();
      DirCacheEntry entry = createEntry("a", FileMode.REGULAR_FILE, 0, "content");
      builder.add(entry);
      entry = createEntry("b", FileMode.REGULAR_FILE, 2, "second file content - master");
      builder.add(entry);
      entry = createEntry("b", FileMode.REGULAR_FILE, 3, "second file content - branch");
      builder.add(entry);
      builder.commit();

      FileTreeIterator iterator = new FileTreeIterator(db);
      IndexDiff diff = new IndexDiff(db, Constants.HEAD, iterator);
      diff.diff();

      assertTrue(diff.getChanged().isEmpty());
      assertTrue(diff.getAdded().isEmpty());
      assertTrue(diff.getRemoved().isEmpty());
      assertTrue(diff.getMissing().isEmpty());
      assertTrue(diff.getModified().isEmpty());
      assertEquals(1, diff.getConflicting().size());
      assertTrue(diff.getConflicting().contains("b"));
      assertEquals(StageState.BOTH_ADDED, diff.getConflictingStageStates().get("b"));
      assertTrue(diff.getUntrackedFolders().isEmpty());
    }
  }
示例#18
0
 public static void commit(File directory, String message) throws GitException {
   try {
     Git git = openRepository(directory);
     git.commit().setMessage(message).call();
   } catch (GitAPIException e) {
     throw new GitException("Commit " + message + " in " + directory + " failed", e);
   }
 }
 private void commit(Git git, String message) throws GitAPIException {
   Status status = git.status().call();
   if (!status.getAdded().isEmpty()
       || !status.getChanged().isEmpty()
       || !status.getRemoved().isEmpty()) {
     git.commit().setMessage(message).call();
   }
 }
示例#20
0
 @Test
 public void resolveUpstream() throws Exception {
   Git git = new Git(db);
   writeTrashFile("file.txt", "content");
   git.add().addFilepattern("file.txt").call();
   RevCommit c1 = git.commit().setMessage("create file").call();
   writeTrashFile("file2.txt", "content");
   RefUpdate updateRemoteRef = db.updateRef("refs/remotes/origin/main");
   updateRemoteRef.setNewObjectId(c1);
   updateRemoteRef.update();
   db.getConfig().setString("branch", "master", "remote", "origin");
   db.getConfig().setString("branch", "master", "merge", "refs/heads/main");
   db.getConfig().setString("remote", "origin", "url", "git://example.com/here");
   db.getConfig().setString("remote", "origin", "fetch", "+refs/heads/*:refs/remotes/origin/*");
   git.add().addFilepattern("file2.txt").call();
   git.commit().setMessage("create file").call();
   assertEquals("refs/remotes/origin/main", db.simplify("@{upstream}"));
 }
  protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (resultCode == RESULT_OK) {
      switch (requestCode) {
        case GitActivity.REQUEST_CLONE:
          // if we get here with a RESULT_OK then it's probably OK :)
          settings.edit().putBoolean("repository_initialized", true).apply();
          break;
        case PgpHandler.REQUEST_CODE_ENCRYPT:
          Git git = new Git(PasswordRepository.getRepository(new File("")));
          GitAsyncTask tasks = new GitAsyncTask(this, false, false, CommitCommand.class);
          tasks.execute(
              git.add().addFilepattern("."),
              git.commit()
                  .setMessage(
                      this.getResources().getString(R.string.add_commit_text)
                          + data.getExtras().getString("NAME")
                          + this.getResources().getString(R.string.from_store)));
          refreshListAdapter();
          break;
        case GitActivity.REQUEST_INIT:
          initializeRepositoryInfo();
          break;
        case GitActivity.REQUEST_PULL:
          updateListAdapter();
          break;
        case HOME:
          checkLocalRepository();
          break;
        case NEW_REPO_BUTTON:
          initializeRepositoryInfo();
          break;
        case CLONE_REPO_BUTTON:
          // duplicate code
          if (settings.getBoolean("git_external", false)
              && settings.getString("git_external_repo", null) != null) {
            String externalRepoPath = settings.getString("git_external_repo", null);
            File dir = externalRepoPath != null ? new File(externalRepoPath) : null;

            if (dir != null
                && dir.exists()
                && dir.isDirectory()
                && !FileUtils.listFiles(dir, null, true).isEmpty()
                && !PasswordRepository.getPasswords(
                        dir, PasswordRepository.getRepositoryDirectory(this))
                    .isEmpty()) {
              PasswordRepository.closeRepository();
              checkLocalRepository();
              return; // if not empty, just show me the passwords!
            }
          }
          Intent intent = new Intent(activity, GitActivity.class);
          intent.putExtra("Operation", GitActivity.REQUEST_CLONE);
          startActivityForResult(intent, GitActivity.REQUEST_CLONE);
          break;
      }
    }
  }
示例#22
0
  @Test
  public void finishHotfixWithNewCommitAndReleaseBranch() throws Exception {
    Git git = RepoUtil.createRepositoryWithMasterAndTag(newDir());
    JGitFlowInitCommand initCommand = new JGitFlowInitCommand();
    JGitFlow flow = initCommand.setDirectory(git.getRepository().getWorkTree()).call();

    flow.releaseStart("1.1").call();

    String releaseName = "release/1.1";

    flow.git().checkout().setName("master").call();

    flow.hotfixStart("1.1.1").call();

    // create a new commit
    File junkFile = new File(git.getRepository().getWorkTree(), "junk.txt");
    FileUtils.writeStringToFile(junkFile, "I am junk");
    git.add().addFilepattern(junkFile.getName()).call();
    RevCommit commit = git.commit().setMessage("committing junk file").call();

    // make sure develop doesn't report our commit yet
    assertFalse(GitHelper.isMergedInto(git, commit, flow.getDevelopBranchName()));

    // make sure release doesn't report our commit yet
    assertFalse(GitHelper.isMergedInto(git, commit, releaseName));

    // try to finish
    flow.hotfixFinish("1.1.1").setKeepBranch(false).call();

    // we should be on develop branch
    assertEquals(flow.getDevelopBranchName(), git.getRepository().getBranch());

    // hotfix branch should be gone
    Ref ref2check = git.getRepository().getRef(flow.getHotfixBranchPrefix() + "1.1.1");
    assertNull(ref2check);

    // the develop branch should have our commit
    assertTrue(GitHelper.isMergedInto(git, commit, flow.getDevelopBranchName()));

    // since fast-forward is suppressed the latest commit on develop should be a merge commit with 2
    // parents
    assertEquals(2, GitHelper.getLatestCommit(git, flow.getDevelopBranchName()).getParentCount());

    // the master branch should have our commit
    assertTrue(GitHelper.isMergedInto(git, commit, getTaggedCommit(git, "1.1.1")));

    // since fast-forward is suppressed the latest commit on master should be a merge commit with 2
    // parents
    assertEquals(2, GitHelper.getLatestCommit(git, getTaggedCommit(git, "1.1.1")).getParentCount());

    // the release branch should have our commit
    assertTrue(GitHelper.isMergedInto(git, commit, releaseName));

    // since fast-forward is suppressed the latest commit on the release branch should be a merge
    // commit with 2 parents
    assertEquals(2, GitHelper.getLatestCommit(git, releaseName).getParentCount());
  }
示例#23
0
 @Test
 public void resolveExprSimple() throws Exception {
   Git git = new Git(db);
   writeTrashFile("file.txt", "content");
   git.add().addFilepattern("file.txt").call();
   git.commit().setMessage("create file").call();
   assertEquals("master", db.simplify("master"));
   assertEquals("refs/heads/master", db.simplify("refs/heads/master"));
   assertEquals("HEAD", db.simplify("HEAD"));
 }
示例#24
0
 /**
  * Commits the current index
  *
  * @param message commit message
  * @return commit object
  * @throws NoHeadException
  * @throws NoMessageException
  * @throws UnmergedPathException
  * @throws ConcurrentRefUpdateException
  * @throws JGitInternalException
  * @throws WrongRepositoryStateException
  */
 public RevCommit commit(String message)
     throws NoHeadException, NoMessageException, UnmergedPathException,
         ConcurrentRefUpdateException, JGitInternalException, WrongRepositoryStateException {
   Git git = new Git(repository);
   CommitCommand commitCommand = git.commit();
   commitCommand.setAuthor("J. Git", "*****@*****.**");
   commitCommand.setCommitter(commitCommand.getAuthor());
   commitCommand.setMessage(message);
   return commitCommand.call();
 }
示例#25
0
  /** @throws Exception */
  @Test
  public void testUntrackedFolders() throws Exception {
    try (Git git = new Git(db)) {
      IndexDiff diff = new IndexDiff(db, Constants.HEAD, new FileTreeIterator(db));
      diff.diff();
      assertEquals(Collections.EMPTY_SET, diff.getUntrackedFolders());

      writeTrashFile("readme", "");
      writeTrashFile("src/com/A.java", "");
      writeTrashFile("src/com/B.java", "");
      writeTrashFile("src/org/A.java", "");
      writeTrashFile("src/org/B.java", "");
      writeTrashFile("target/com/A.java", "");
      writeTrashFile("target/com/B.java", "");
      writeTrashFile("target/org/A.java", "");
      writeTrashFile("target/org/B.java", "");

      git.add().addFilepattern("src").addFilepattern("readme").call();
      git.commit().setMessage("initial").call();

      diff = new IndexDiff(db, Constants.HEAD, new FileTreeIterator(db));
      diff.diff();
      assertEquals(new HashSet<String>(Arrays.asList("target")), diff.getUntrackedFolders());

      writeTrashFile("src/tst/A.java", "");
      writeTrashFile("src/tst/B.java", "");

      diff = new IndexDiff(db, Constants.HEAD, new FileTreeIterator(db));
      diff.diff();
      assertEquals(
          new HashSet<String>(Arrays.asList("target", "src/tst")), diff.getUntrackedFolders());

      git.rm().addFilepattern("src/com/B.java").addFilepattern("src/org").call();
      git.commit().setMessage("second").call();
      writeTrashFile("src/org/C.java", "");

      diff = new IndexDiff(db, Constants.HEAD, new FileTreeIterator(db));
      diff.diff();
      assertEquals(
          new HashSet<String>(Arrays.asList("src/org", "src/tst", "target")),
          diff.getUntrackedFolders());
    }
  }
示例#26
0
  @Test
  public void finishHotfixWithMultipleCommits() throws Exception {
    Git git = RepoUtil.createRepositoryWithMasterAndTag(newDir());
    JGitFlowInitCommand initCommand = new JGitFlowInitCommand();
    JGitFlow flow = initCommand.setDirectory(git.getRepository().getWorkTree()).call();

    flow.hotfixStart("1.1").call();

    // create a new commit
    File junkFile = new File(git.getRepository().getWorkTree(), "junk.txt");
    FileUtils.writeStringToFile(junkFile, "I am junk");
    git.add().addFilepattern(junkFile.getName()).call();
    RevCommit commit = git.commit().setMessage("committing junk file").call();

    // create second commit
    File junkFile2 = new File(git.getRepository().getWorkTree(), "junk2.txt");
    FileUtils.writeStringToFile(junkFile2, "I am junk, and so are you");
    git.add().addFilepattern(junkFile2.getName()).call();
    RevCommit commit2 = git.commit().setMessage("updating junk file").call();

    // make sure develop doesn't have our commits yet
    assertFalse(GitHelper.isMergedInto(git, commit, flow.getDevelopBranchName()));
    assertFalse(GitHelper.isMergedInto(git, commit2, flow.getDevelopBranchName()));

    // try to finish
    flow.hotfixFinish("1.1").call();

    // we should be on develop branch
    assertEquals(flow.getDevelopBranchName(), git.getRepository().getBranch());

    // release branch should be gone
    Ref ref2check = git.getRepository().getRef(flow.getHotfixBranchPrefix() + "1.1");
    assertNull(ref2check);

    // the develop branch should have both of our commits now
    assertTrue(GitHelper.isMergedInto(git, commit, flow.getDevelopBranchName()));
    assertTrue(GitHelper.isMergedInto(git, commit2, flow.getDevelopBranchName()));

    // the master branch should have both of our commits now
    assertTrue(GitHelper.isMergedInto(git, commit, getTaggedCommit(git, "1.1")));
    assertTrue(GitHelper.isMergedInto(git, commit2, getTaggedCommit(git, "1.1")));
  }
示例#27
0
 /**
  * Adds changes to the staging index. Then makes commit.
  *
  * @param message the commit message
  * @param name the name of the committer used for the commit
  * @param email the email of the committer used for the commit
  * @param all if set to true, command will automatically stages files that have been modified and
  *     deleted, but new files not known by the repository are not affected. This corresponds to
  *     the parameter -a on the command line.
  * @throws NoHeadException
  * @throws NoMessageException
  * @throws UnmergedPathsException
  * @throws ConcurrentRefUpdateException
  * @throws WrongRepositoryStateException
  * @throws GitAPIException
  * @throws IOException
  */
 public void commit(String message, String name, String email, boolean all)
     throws NoHeadException, NoMessageException, UnmergedPathsException,
         ConcurrentRefUpdateException, WrongRepositoryStateException, GitAPIException,
         IOException {
   CommitCommand commitCommand = git.commit();
   commitCommand.setMessage(message);
   commitCommand.setCommitter(name, email);
   commitCommand.setAuthor(name, email);
   commitCommand.setAll(all);
   commitCommand.call();
 }
示例#28
0
  @Test
  public void testConflicting() throws Exception {
    try (Git git = new Git(db)) {
      writeTrashFile("a", "1\na\n3\n");
      writeTrashFile("b", "1\nb\n3\n");
      git.add().addFilepattern("a").addFilepattern("b").call();
      RevCommit initialCommit = git.commit().setMessage("initial").call();

      // create side branch with two modifications
      createBranch(initialCommit, "refs/heads/side");
      checkoutBranch("refs/heads/side");
      writeTrashFile("a", "1\na(side)\n3\n");
      writeTrashFile("b", "1\nb\n3\n(side)");
      git.add().addFilepattern("a").addFilepattern("b").call();
      RevCommit secondCommit = git.commit().setMessage("side").call();

      // update a on master to generate conflict
      checkoutBranch("refs/heads/master");
      writeTrashFile("a", "1\na(main)\n3\n");
      git.add().addFilepattern("a").call();
      git.commit().setMessage("main").call();

      // merge side with master
      MergeResult result =
          git.merge().include(secondCommit.getId()).setStrategy(MergeStrategy.RESOLVE).call();
      assertEquals(MergeStatus.CONFLICTING, result.getMergeStatus());
    }

    FileTreeIterator iterator = new FileTreeIterator(db);
    IndexDiff diff = new IndexDiff(db, Constants.HEAD, iterator);
    diff.diff();

    assertEquals("[b]", new TreeSet<String>(diff.getChanged()).toString());
    assertEquals("[]", diff.getAdded().toString());
    assertEquals("[]", diff.getRemoved().toString());
    assertEquals("[]", diff.getMissing().toString());
    assertEquals("[]", diff.getModified().toString());
    assertEquals("[a]", diff.getConflicting().toString());
    assertEquals(StageState.BOTH_MODIFIED, diff.getConflictingStageStates().get("a"));
    assertEquals(Collections.EMPTY_SET, diff.getUntrackedFolders());
  }
 private void commit(Git git, String message) throws IOException {
   CommitCommand commit = git.commit();
   try {
     commit.setMessage(message).call();
   } catch (GitAPIException e) {
     throw new IOException(e);
   } catch (UnmergedPathException e) {
     throw new IOException(e);
   } catch (JGitInternalException e) {
     throw new IOException(e);
   }
 }
示例#30
0
  @Test
  public void testGitPgm() throws Exception {
    Path targetParent = detectTargetFolder().getParent();
    Path serverDir = getTempTargetRelativeFile(getClass().getSimpleName());

    //
    // TODO: the GitpgmCommandFactory is kept in the test tree
    // TODO: because it's quite limited for now
    //

    try (SshServer sshd = setupTestServer()) {
      sshd.setSubsystemFactories(Arrays.<NamedFactory<Command>>asList(new SftpSubsystemFactory()));
      sshd.setCommandFactory(
          new GitPgmCommandFactory(Utils.resolveRelativeRemotePath(targetParent, serverDir)));
      sshd.start();

      int port = sshd.getPort();
      try {
        Utils.deleteRecursive(serverDir);

        try (SshClient client = setupTestClient()) {
          client.start();

          try (ClientSession session =
              client
                  .connect(getCurrentTestName(), SshdSocketAddress.LOCALHOST_IP, port)
                  .verify(7L, TimeUnit.SECONDS)
                  .getSession()) {
            session.addPasswordIdentity(getCurrentTestName());
            session.auth().verify(5L, TimeUnit.SECONDS);

            Path repo = serverDir.resolve(getCurrentTestName());
            Git.init().setDirectory(repo.toFile()).call();
            Git git = Git.open(repo.toFile());
            git.commit()
                .setMessage("First Commit")
                .setCommitter(getCurrentTestName(), "*****@*****.**")
                .call();

            Path readmeFile = Files.createFile(repo.resolve("readme.txt"));
            String commandPrefix = "git --git-dir " + repo.getFileName();
            execute(session, commandPrefix + " add " + readmeFile.getFileName());
            execute(session, commandPrefix + " commit -m \"readme\"");
          } finally {
            client.stop();
          }
        }
      } finally {
        sshd.stop();
      }
    }
  }