Example usage for org.eclipse.jgit.lib RefUpdate disableRefLog

List of usage examples for org.eclipse.jgit.lib RefUpdate disableRefLog

  1. HOME
  2. Java
  3. org.eclipse.jgit
  4. org.eclipse.jgit.lib.*
  5. RefUpdate
  6. disableRefLog

Introduction

In this page you can find the example usage for org.eclipse.jgit.lib RefUpdate disableRefLog.

Prototype

public void disableRefLog()

Source Link

Document

Don't record this update in the ref's associated reflog.

Usage

From source file:com.google.gerrit.server.change.CherryPickChange.java

License:Apache License

private Change createNewChange(Repository git, RevWalk revWalk, Change.Key changeKey, Project.NameKey project,
        Ref destRef, CodeReviewCommit cherryPickCommit, RefControl refControl, IdentifiedUser identifiedUser,
        String topic) throws OrmException, InvalidChangeOperationException, IOException {
    Change change = new Change(changeKey, new Change.Id(db.get().nextChangeId()), identifiedUser.getAccountId(),
            new Branch.NameKey(project, destRef.getName()), TimeUtil.nowTs());
    change.setTopic(topic);// w ww  . ja  v a 2  s.c om
    ChangeInserter ins = changeInserterFactory.create(refControl.getProjectControl(), change, cherryPickCommit);
    PatchSet newPatchSet = ins.getPatchSet();

    CommitValidators commitValidators = commitValidatorsFactory.create(refControl, new NoSshInfo(), git);
    CommitReceivedEvent commitReceivedEvent = new CommitReceivedEvent(
            new ReceiveCommand(ObjectId.zeroId(), cherryPickCommit.getId(), newPatchSet.getRefName()),
            refControl.getProjectControl().getProject(), refControl.getRefName(), cherryPickCommit,
            identifiedUser);

    try {
        commitValidators.validateForGerritCommits(commitReceivedEvent);
    } catch (CommitValidationException e) {
        throw new InvalidChangeOperationException(e.getMessage());
    }

    final RefUpdate ru = git.updateRef(newPatchSet.getRefName());
    ru.setExpectedOldObjectId(ObjectId.zeroId());
    ru.setNewObjectId(cherryPickCommit);
    ru.disableRefLog();
    if (ru.update(revWalk) != RefUpdate.Result.NEW) {
        throw new IOException(String.format("Failed to create ref %s in %s: %s", newPatchSet.getRefName(),
                change.getDest().getParentKey().get(), ru.getResult()));
    }

    ins.insert();

    return change;
}

From source file:com.google.gerrit.server.change.CreateChange.java

License:Apache License

private static void updateRef(Repository git, RevWalk rw, RevCommit c, Change change, PatchSet newPatchSet)
        throws IOException {
    RefUpdate ru = git.updateRef(newPatchSet.getRefName());
    ru.setExpectedOldObjectId(ObjectId.zeroId());
    ru.setNewObjectId(c);//from  w  w w  .ja  v a2  s  . c  om
    ru.disableRefLog();
    if (ru.update(rw) != RefUpdate.Result.NEW) {
        throw new IOException(String.format("Failed to create ref %s in %s: %s", newPatchSet.getRefName(),
                change.getDest().getParentKey().get(), ru.getResult()));
    }
}

From source file:com.google.gerrit.server.change.PatchSetInserter.java

License:Apache License

public Change insert()
        throws InvalidChangeOperationException, OrmException, IOException, NoSuchChangeException {
    init();/*w w w.  j  a v a  2 s .com*/
    validate();

    Change c = ctl.getChange();
    Change updatedChange;
    RefUpdate ru = git.updateRef(patchSet.getRefName());
    ru.setExpectedOldObjectId(ObjectId.zeroId());
    ru.setNewObjectId(commit);
    ru.disableRefLog();
    if (ru.update(revWalk) != RefUpdate.Result.NEW) {
        throw new IOException(String.format("Failed to create ref %s in %s: %s", patchSet.getRefName(),
                c.getDest().getParentKey().get(), ru.getResult()));
    }
    gitRefUpdated.fire(c.getProject(), ru);

    final PatchSet.Id currentPatchSetId = c.currentPatchSetId();

    ChangeUpdate update = updateFactory.create(ctl, patchSet.getCreatedOn());

    db.changes().beginTransaction(c.getId());
    try {
        updatedChange = db.changes().get(c.getId());
        if (!updatedChange.getStatus().isOpen() && !allowClosed) {
            throw new InvalidChangeOperationException(String.format("Change %s is closed", c.getId()));
        }

        ChangeUtil.insertAncestors(db, patchSet.getId(), commit);
        if (groups != null) {
            patchSet.setGroups(groups);
        } else {
            patchSet.setGroups(GroupCollector.getCurrentGroups(db, c));
        }
        db.patchSets().insert(Collections.singleton(patchSet));

        SetMultimap<ReviewerState, Account.Id> oldReviewers = sendMail
                ? approvalsUtil.getReviewers(db, ctl.getNotes())
                : null;

        updatedChange = db.changes().atomicUpdate(c.getId(), new AtomicUpdate<Change>() {
            @Override
            public Change update(Change change) {
                if (change.getStatus().isClosed() && !allowClosed) {
                    return null;
                }
                if (!change.currentPatchSetId().equals(currentPatchSetId)) {
                    return null;
                }
                if (change.getStatus() != Change.Status.DRAFT && !allowClosed) {
                    change.setStatus(Change.Status.NEW);
                }
                change.setCurrentPatchSet(patchSetInfoFactory.get(commit, patchSet.getId()));
                ChangeUtil.updated(change);
                return change;
            }
        });
        if (updatedChange == null) {
            throw new ChangeModifiedException(String.format("Change %s was modified", c.getId()));
        }

        if (messageIsForChange()) {
            cmUtil.addChangeMessage(db, update, changeMessage);
        }

        approvalCopier.copy(db, ctl, patchSet);
        db.commit();
        if (messageIsForChange()) {
            update.commit();
        }

        if (!messageIsForChange()) {
            commitMessageNotForChange(updatedChange);
        }

        if (sendMail) {
            try {
                PatchSetInfo info = patchSetInfoFactory.get(commit, patchSet.getId());
                ReplacePatchSetSender cm = replacePatchSetFactory.create(c.getId());
                cm.setFrom(user.getAccountId());
                cm.setPatchSet(patchSet, info);
                cm.setChangeMessage(changeMessage);
                cm.addReviewers(oldReviewers.get(ReviewerState.REVIEWER));
                cm.addExtraCC(oldReviewers.get(ReviewerState.CC));
                cm.send();
            } catch (Exception err) {
                log.error("Cannot send email for new patch set on change " + updatedChange.getId(), err);
            }
        }

    } finally {
        db.rollback();
    }
    indexer.index(db, updatedChange);
    if (runHooks) {
        hooks.doPatchsetCreatedHook(updatedChange, patchSet, db);
    }
    return updatedChange;
}

From source file:com.google.gerrit.server.ChangeUtil.java

License:Apache License

public Change.Id revert(ChangeControl ctl, PatchSet.Id patchSetId, String message, PersonIdent myIdent,
        SshInfo sshInfo) throws NoSuchChangeException, OrmException, MissingObjectException,
        IncorrectObjectTypeException, IOException, InvalidChangeOperationException {
    Change.Id changeId = patchSetId.getParentKey();
    PatchSet patch = db.get().patchSets().get(patchSetId);
    if (patch == null) {
        throw new NoSuchChangeException(changeId);
    }/*from   w  ww  .ja  va  2s.  c o m*/
    Change changeToRevert = db.get().changes().get(changeId);

    Project.NameKey project = ctl.getChange().getProject();
    try (Repository git = gitManager.openRepository(project); RevWalk revWalk = new RevWalk(git)) {
        RevCommit commitToRevert = revWalk.parseCommit(ObjectId.fromString(patch.getRevision().get()));

        PersonIdent authorIdent = user().newCommitterIdent(myIdent.getWhen(), myIdent.getTimeZone());

        RevCommit parentToCommitToRevert = commitToRevert.getParent(0);
        revWalk.parseHeaders(parentToCommitToRevert);

        CommitBuilder revertCommitBuilder = new CommitBuilder();
        revertCommitBuilder.addParentId(commitToRevert);
        revertCommitBuilder.setTreeId(parentToCommitToRevert.getTree());
        revertCommitBuilder.setAuthor(authorIdent);
        revertCommitBuilder.setCommitter(authorIdent);

        if (message == null) {
            message = MessageFormat.format(ChangeMessages.get().revertChangeDefaultMessage,
                    changeToRevert.getSubject(), patch.getRevision().get());
        }

        ObjectId computedChangeId = ChangeIdUtil.computeChangeId(parentToCommitToRevert.getTree(),
                commitToRevert, authorIdent, myIdent, message);
        revertCommitBuilder.setMessage(ChangeIdUtil.insertId(message, computedChangeId, true));

        RevCommit revertCommit;
        try (ObjectInserter oi = git.newObjectInserter()) {
            ObjectId id = oi.insert(revertCommitBuilder);
            oi.flush();
            revertCommit = revWalk.parseCommit(id);
        }

        RefControl refControl = ctl.getRefControl();
        Change change = new Change(new Change.Key("I" + computedChangeId.name()),
                new Change.Id(db.get().nextChangeId()), user().getAccountId(), changeToRevert.getDest(),
                TimeUtil.nowTs());
        change.setTopic(changeToRevert.getTopic());
        ChangeInserter ins = changeInserterFactory.create(refControl.getProjectControl(), change, revertCommit);
        PatchSet ps = ins.getPatchSet();

        String ref = refControl.getRefName();
        String cmdRef = MagicBranch.NEW_PUBLISH_CHANGE + ref.substring(ref.lastIndexOf('/') + 1);
        CommitReceivedEvent commitReceivedEvent = new CommitReceivedEvent(
                new ReceiveCommand(ObjectId.zeroId(), revertCommit.getId(), cmdRef),
                refControl.getProjectControl().getProject(), refControl.getRefName(), revertCommit, user());

        try {
            commitValidatorsFactory.create(refControl, sshInfo, git)
                    .validateForGerritCommits(commitReceivedEvent);
        } catch (CommitValidationException e) {
            throw new InvalidChangeOperationException(e.getMessage());
        }

        RefUpdate ru = git.updateRef(ps.getRefName());
        ru.setExpectedOldObjectId(ObjectId.zeroId());
        ru.setNewObjectId(revertCommit);
        ru.disableRefLog();
        if (ru.update(revWalk) != RefUpdate.Result.NEW) {
            throw new IOException(String.format("Failed to create ref %s in %s: %s", ps.getRefName(),
                    change.getDest().getParentKey().get(), ru.getResult()));
        }

        ChangeMessage cmsg = new ChangeMessage(new ChangeMessage.Key(changeId, messageUUID(db.get())),
                user().getAccountId(), TimeUtil.nowTs(), patchSetId);
        StringBuilder msgBuf = new StringBuilder();
        msgBuf.append("Patch Set ").append(patchSetId.get()).append(": Reverted");
        msgBuf.append("\n\n");
        msgBuf.append("This patchset was reverted in change: ").append(change.getKey().get());
        cmsg.setMessage(msgBuf.toString());

        ins.setMessage(cmsg).insert();

        try {
            RevertedSender cm = revertedSenderFactory.create(change.getId());
            cm.setFrom(user().getAccountId());
            cm.setChangeMessage(cmsg);
            cm.send();
        } catch (Exception err) {
            log.error("Cannot send email for revert change " + change.getId(), err);
        }

        return change.getId();
    } catch (RepositoryNotFoundException e) {
        throw new NoSuchChangeException(changeId, e);
    }
}

From source file:com.google.gerrit.server.ChangeUtil.java

License:Apache License

public void deleteOnlyDraftPatchSet(PatchSet patch, Change change)
        throws NoSuchChangeException, OrmException, IOException {
    PatchSet.Id patchSetId = patch.getId();
    if (!patch.isDraft()) {
        throw new NoSuchChangeException(patchSetId.getParentKey());
    }//from   w w w  .  ja  v a2  s . c  o m

    try (Repository repo = gitManager.openRepository(change.getProject())) {
        RefUpdate update = repo.updateRef(patch.getRefName());
        update.setForceUpdate(true);
        update.disableRefLog();
        switch (update.delete()) {
        case NEW:
        case FAST_FORWARD:
        case FORCED:
        case NO_CHANGE:
            // Successful deletion.
            break;
        default:
            throw new IOException("Failed to delete ref " + patch.getRefName() + " in " + repo.getDirectory()
                    + ": " + update.getResult());
        }
        gitRefUpdated.fire(change.getProject(), update, ReceiveCommand.Type.DELETE);
    }

    deleteOnlyDraftPatchSetPreserveRef(this.db.get(), patch);
}

From source file:com.google.gerrit.server.git.CherryPick.java

License:Apache License

private CodeReviewCommit writeCherryPickCommit(final CodeReviewCommit mergeTip, final CodeReviewCommit n)
        throws IOException, OrmException {

    args.rw.parseBody(n);/*from   w  ww.jav a2  s  .  c o  m*/

    final PatchSetApproval submitAudit = args.mergeUtil.getSubmitter(n.change.currentPatchSetId());

    PersonIdent cherryPickCommitterIdent = null;
    if (submitAudit != null) {
        cherryPickCommitterIdent = args.identifiedUserFactory.create(submitAudit.getAccountId())
                .newCommitterIdent(submitAudit.getGranted(), args.myIdent.getTimeZone());
    } else {
        cherryPickCommitterIdent = args.myIdent;
    }

    final String cherryPickCmtMsg = args.mergeUtil.createCherryPickCommitMessage(n);

    final CodeReviewCommit newCommit = (CodeReviewCommit) args.mergeUtil.createCherryPickFromCommit(args.repo,
            args.inserter, mergeTip, n, cherryPickCommitterIdent, cherryPickCmtMsg, args.rw);

    if (newCommit == null) {
        return null;
    }

    PatchSet.Id id = ChangeUtil.nextPatchSetId(args.repo, n.change.currentPatchSetId());
    final PatchSet ps = new PatchSet(id);
    ps.setCreatedOn(new Timestamp(System.currentTimeMillis()));
    ps.setUploader(submitAudit.getAccountId());
    ps.setRevision(new RevId(newCommit.getId().getName()));
    insertAncestors(args.db, ps.getId(), newCommit);
    args.db.patchSets().insert(Collections.singleton(ps));

    n.change.setCurrentPatchSet(patchSetInfoFactory.get(newCommit, ps.getId()));
    args.db.changes().update(Collections.singletonList(n.change));

    final List<PatchSetApproval> approvals = Lists.newArrayList();
    for (PatchSetApproval a : args.mergeUtil.getApprovalsForCommit(n)) {
        approvals.add(new PatchSetApproval(ps.getId(), a));
    }
    args.db.patchSetApprovals().insert(approvals);

    final RefUpdate ru = args.repo.updateRef(ps.getRefName());
    ru.setExpectedOldObjectId(ObjectId.zeroId());
    ru.setNewObjectId(newCommit);
    ru.disableRefLog();
    if (ru.update(args.rw) != RefUpdate.Result.NEW) {
        throw new IOException(String.format("Failed to create ref %s in %s: %s", ps.getRefName(),
                n.change.getDest().getParentKey().get(), ru.getResult()));
    }

    gitRefUpdated.fire(n.change.getProject(), ru);

    newCommit.copyFrom(n);
    newCommit.statusCode = CommitMergeStatus.CLEAN_PICK;
    newCommits.put(newCommit.patchsetId.getParentKey(), newCommit);
    setRefLogIdent(submitAudit);
    return newCommit;
}

From source file:com.google.gerrit.server.git.ProjectConfigTest.java

License:Apache License

private void update(RevCommit rev) throws Exception {
    RefUpdate u = db.updateRef(RefNames.REFS_CONFIG);
    u.disableRefLog();
    u.setNewObjectId(rev);//from  w  w  w  .  j av  a  2 s .c o  m
    Result result = u.forceUpdate();
    assert_().withFailureMessage("Cannot update ref for test: " + result).that(result)
            .isAnyOf(Result.FAST_FORWARD, Result.FORCED, Result.NEW, Result.NO_CHANGE);
}

From source file:com.google.gerrit.server.git.strategy.CherryPick.java

License:Apache License

private CodeReviewCommit writeCherryPickCommit(CodeReviewCommit mergeTip, CodeReviewCommit n)
        throws IOException, OrmException, NoSuchChangeException, MergeConflictException,
        MergeIdenticalTreeException {/*from  ww  w.jav  a 2s .  c  o  m*/

    args.rw.parseBody(n);

    String cherryPickCmtMsg = args.mergeUtil.createCherryPickCommitMessage(n);

    PersonIdent committer = args.caller.newCommitterIdent(TimeUtil.nowTs(),
            args.serverIdent.get().getTimeZone());
    CodeReviewCommit newCommit = args.mergeUtil.createCherryPickFromCommit(args.repo, args.inserter, mergeTip,
            n, committer, cherryPickCmtMsg, args.rw);

    PatchSet.Id id = ChangeUtil.nextPatchSetId(args.repo, n.change().currentPatchSetId());
    PatchSet ps = new PatchSet(id);
    ps.setCreatedOn(TimeUtil.nowTs());
    ps.setUploader(args.caller.getAccountId());
    ps.setRevision(new RevId(newCommit.getId().getName()));

    RefUpdate ru;

    args.db.changes().beginTransaction(n.change().getId());
    try {
        insertAncestors(args.db, ps.getId(), newCommit);
        ps.setGroups(GroupCollector.getCurrentGroups(args.db, n.change()));
        args.db.patchSets().insert(Collections.singleton(ps));
        n.change().setCurrentPatchSet(patchSetInfoFactory.get(newCommit, ps.getId()));
        args.db.changes().update(Collections.singletonList(n.change()));

        List<PatchSetApproval> approvals = Lists.newArrayList();
        for (PatchSetApproval a : args.approvalsUtil.byPatchSet(args.db, n.getControl(), n.getPatchsetId())) {
            approvals.add(new PatchSetApproval(ps.getId(), a));
        }
        args.db.patchSetApprovals().insert(approvals);

        ru = args.repo.updateRef(ps.getRefName());
        ru.setExpectedOldObjectId(ObjectId.zeroId());
        ru.setNewObjectId(newCommit);
        ru.disableRefLog();
        if (ru.update(args.rw) != RefUpdate.Result.NEW) {
            throw new IOException(String.format("Failed to create ref %s in %s: %s", ps.getRefName(),
                    n.change().getDest().getParentKey().get(), ru.getResult()));
        }

        args.db.commit();
    } finally {
        args.db.rollback();
    }

    gitRefUpdated.fire(n.change().getProject(), ru);

    newCommit.copyFrom(n);
    newCommit.setStatusCode(CommitMergeStatus.CLEAN_PICK);
    newCommit.setControl(args.changeControlFactory.controlFor(n.change(), args.caller));
    newCommits.put(newCommit.getPatchsetId().getParentKey(), newCommit);
    setRefLogIdent();
    return newCommit;
}

From source file:com.google.gerrit.server.patch.AutoMerger.java

License:Apache License

private RevCommit commit(Repository repo, RevWalk rw, ObjectInserter ins, String refName, ObjectId tree,
        RevCommit merge) throws IOException {
    rw.parseHeaders(merge);/* w  ww. ja  v  a  2 s .co  m*/
    // For maximum stability, choose a single ident using the committer time of
    // the input commit, using the server name and timezone.
    PersonIdent ident = new PersonIdent(gerritIdent, merge.getCommitterIdent().getWhen(),
            gerritIdent.getTimeZone());
    CommitBuilder cb = new CommitBuilder();
    cb.setAuthor(ident);
    cb.setCommitter(ident);
    cb.setTreeId(tree);
    cb.setMessage("Auto-merge of " + merge.name() + '\n');
    for (RevCommit p : merge.getParents()) {
        cb.addParentId(p);
    }
    ObjectId commitId;
    commitId = ins.insert(cb);
    if (save) {
        ins.flush();

        RefUpdate ru = repo.updateRef(refName);
        ru.setNewObjectId(commitId);
        ru.disableRefLog();
        ru.forceUpdate();
    }
    return rw.parseCommit(commitId);
}

From source file:com.google.gerrit.server.patch.PatchListLoader.java

License:Apache License

public static RevTree automerge(Repository repo, RevWalk rw, RevCommit b, ThreeWayMergeStrategy mergeStrategy,
        boolean save) throws IOException {
    String hash = b.name();/*w w w .ja  v  a2 s  . com*/
    String refName = RefNames.REFS_CACHE_AUTOMERGE + hash.substring(0, 2) + "/" + hash.substring(2);
    Ref ref = repo.getRefDatabase().exactRef(refName);
    if (ref != null && ref.getObjectId() != null) {
        return rw.parseTree(ref.getObjectId());
    }

    ResolveMerger m = (ResolveMerger) mergeStrategy.newMerger(repo, true);
    try (ObjectInserter ins = repo.newObjectInserter()) {
        DirCache dc = DirCache.newInCore();
        m.setDirCache(dc);
        m.setObjectInserter(new ObjectInserter.Filter() {
            @Override
            protected ObjectInserter delegate() {
                return ins;
            }

            @Override
            public void flush() {
            }

            @Override
            public void close() {
            }
        });

        boolean couldMerge;
        try {
            couldMerge = m.merge(b.getParents());
        } catch (IOException e) {
            // It is not safe to continue further down in this method as throwing
            // an exception most likely means that the merge tree was not created
            // and m.getMergeResults() is empty. This would mean that all paths are
            // unmerged and Gerrit UI would show all paths in the patch list.
            log.warn("Error attempting automerge " + refName, e);
            return null;
        }

        ObjectId treeId;
        if (couldMerge) {
            treeId = m.getResultTreeId();

        } else {
            RevCommit ours = b.getParent(0);
            RevCommit theirs = b.getParent(1);
            rw.parseBody(ours);
            rw.parseBody(theirs);
            String oursMsg = ours.getShortMessage();
            String theirsMsg = theirs.getShortMessage();

            String oursName = String.format("HEAD   (%s %s)", ours.abbreviate(6).name(),
                    oursMsg.substring(0, Math.min(oursMsg.length(), 60)));
            String theirsName = String.format("BRANCH (%s %s)", theirs.abbreviate(6).name(),
                    theirsMsg.substring(0, Math.min(theirsMsg.length(), 60)));

            MergeFormatter fmt = new MergeFormatter();
            Map<String, MergeResult<? extends Sequence>> r = m.getMergeResults();
            Map<String, ObjectId> resolved = new HashMap<>();
            for (Map.Entry<String, MergeResult<? extends Sequence>> entry : r.entrySet()) {
                MergeResult<? extends Sequence> p = entry.getValue();
                try (TemporaryBuffer buf = new TemporaryBuffer.LocalFile(null, 10 * 1024 * 1024)) {
                    fmt.formatMerge(buf, p, "BASE", oursName, theirsName, "UTF-8");
                    buf.close();

                    try (InputStream in = buf.openInputStream()) {
                        resolved.put(entry.getKey(), ins.insert(Constants.OBJ_BLOB, buf.length(), in));
                    }
                }
            }

            DirCacheBuilder builder = dc.builder();
            int cnt = dc.getEntryCount();
            for (int i = 0; i < cnt;) {
                DirCacheEntry entry = dc.getEntry(i);
                if (entry.getStage() == 0) {
                    builder.add(entry);
                    i++;
                    continue;
                }

                int next = dc.nextEntry(i);
                String path = entry.getPathString();
                DirCacheEntry res = new DirCacheEntry(path);
                if (resolved.containsKey(path)) {
                    // For a file with content merge conflict that we produced a result
                    // above on, collapse the file down to a single stage 0 with just
                    // the blob content, and a randomly selected mode (the lowest stage,
                    // which should be the merge base, or ours).
                    res.setFileMode(entry.getFileMode());
                    res.setObjectId(resolved.get(path));

                } else if (next == i + 1) {
                    // If there is exactly one stage present, shouldn't be a conflict...
                    res.setFileMode(entry.getFileMode());
                    res.setObjectId(entry.getObjectId());

                } else if (next == i + 2) {
                    // Two stages suggests a delete/modify conflict. Pick the higher
                    // stage as the automatic result.
                    entry = dc.getEntry(i + 1);
                    res.setFileMode(entry.getFileMode());
                    res.setObjectId(entry.getObjectId());

                } else { // 3 stage conflict, no resolve above
                    // Punt on the 3-stage conflict and show the base, for now.
                    res.setFileMode(entry.getFileMode());
                    res.setObjectId(entry.getObjectId());
                }
                builder.add(res);
                i = next;
            }
            builder.finish();
            treeId = dc.writeTree(ins);
        }
        ins.flush();

        if (save) {
            RefUpdate update = repo.updateRef(refName);
            update.setNewObjectId(treeId);
            update.disableRefLog();
            update.forceUpdate();
        }

        return rw.lookupTree(treeId);
    }
}