Java tutorial
// Copyright (C) 2017 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package com.google.gerrit.server.account; import static com.google.common.base.Preconditions.checkNotNull; import com.google.common.collect.ImmutableSet; import com.google.gerrit.reviewdb.client.Account; import com.google.gerrit.reviewdb.client.RefNames; import com.google.gerrit.reviewdb.server.ReviewDb; import com.google.gerrit.server.GerritPersonIdent; import com.google.gerrit.server.IdentifiedUser; import com.google.gerrit.server.config.AllUsersName; import com.google.gerrit.server.git.GitRepositoryManager; import com.google.gwtorm.server.OrmDuplicateKeyException; import com.google.gwtorm.server.OrmException; import com.google.inject.Inject; import com.google.inject.Provider; import com.google.inject.Singleton; import java.io.IOException; import java.sql.Timestamp; import org.eclipse.jgit.lib.CommitBuilder; import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.lib.ObjectId; import org.eclipse.jgit.lib.ObjectInserter; import org.eclipse.jgit.lib.PersonIdent; import org.eclipse.jgit.lib.Ref; import org.eclipse.jgit.lib.RefUpdate; import org.eclipse.jgit.lib.RefUpdate.Result; import org.eclipse.jgit.lib.Repository; /** Updates accounts. */ @Singleton public class AccountsUpdate { /** * Factory to create an AccountsUpdate instance for updating accounts by the Gerrit server. * * <p>The Gerrit server identity will be used as author and committer for all commits that update * the accounts. */ @Singleton public static class Server { private final GitRepositoryManager repoManager; private final AllUsersName allUsersName; private final Provider<PersonIdent> serverIdent; @Inject public Server(GitRepositoryManager repoManager, AllUsersName allUsersName, @GerritPersonIdent Provider<PersonIdent> serverIdent) { this.repoManager = repoManager; this.allUsersName = allUsersName; this.serverIdent = serverIdent; } public AccountsUpdate create() { PersonIdent i = serverIdent.get(); return new AccountsUpdate(repoManager, allUsersName, i, i); } } /** * Factory to create an AccountsUpdate instance for updating accounts by the current user. * * <p>The identity of the current user will be used as author for all commits that update the * accounts. The Gerrit server identity will be used as committer. */ @Singleton public static class User { private final GitRepositoryManager repoManager; private final AllUsersName allUsersName; private final Provider<PersonIdent> serverIdent; private final Provider<IdentifiedUser> identifiedUser; @Inject public User(GitRepositoryManager repoManager, AllUsersName allUsersName, @GerritPersonIdent Provider<PersonIdent> serverIdent, Provider<IdentifiedUser> identifiedUser) { this.repoManager = repoManager; this.allUsersName = allUsersName; this.serverIdent = serverIdent; this.identifiedUser = identifiedUser; } public AccountsUpdate create() { PersonIdent i = serverIdent.get(); return new AccountsUpdate(repoManager, allUsersName, createPersonIdent(i, identifiedUser.get()), i); } private PersonIdent createPersonIdent(PersonIdent ident, IdentifiedUser user) { return user.newCommitterIdent(ident.getWhen(), ident.getTimeZone()); } } private final GitRepositoryManager repoManager; private final AllUsersName allUsersName; private final PersonIdent committerIdent; private final PersonIdent authorIdent; private AccountsUpdate(GitRepositoryManager repoManager, AllUsersName allUsersName, PersonIdent committerIdent, PersonIdent authorIdent) { this.repoManager = checkNotNull(repoManager, "repoManager"); this.allUsersName = checkNotNull(allUsersName, "allUsersName"); this.committerIdent = checkNotNull(committerIdent, "committerIdent"); this.authorIdent = checkNotNull(authorIdent, "authorIdent"); } /** * Inserts a new account. * * @throws OrmDuplicateKeyException if the account already exists * @throws IOException if updating the user branch fails */ public void insert(ReviewDb db, Account account) throws OrmException, IOException { db.accounts().insert(ImmutableSet.of(account)); createUserBranch(account); } /** * Inserts or updates an account. * * <p>If the account already exists, it is overwritten, otherwise it is inserted. */ public void upsert(ReviewDb db, Account account) throws OrmException, IOException { db.accounts().upsert(ImmutableSet.of(account)); createUserBranchIfNeeded(account); } /** Deletes the account. */ public void delete(ReviewDb db, Account account) throws OrmException, IOException { db.accounts().delete(ImmutableSet.of(account)); deleteUserBranch(account.getId()); } /** Deletes the account. */ public void deleteByKey(ReviewDb db, Account.Id accountId) throws OrmException, IOException { db.accounts().deleteKeys(ImmutableSet.of(accountId)); deleteUserBranch(accountId); } private void createUserBranch(Account account) throws IOException { try (Repository repo = repoManager.openRepository(allUsersName); ObjectInserter oi = repo.newObjectInserter()) { String refName = RefNames.refsUsers(account.getId()); if (repo.exactRef(refName) != null) { throw new IOException(String.format("User branch %s for newly created account %s already exists.", refName, account.getId().get())); } createUserBranch(repo, oi, committerIdent, authorIdent, account); } } private void createUserBranchIfNeeded(Account account) throws IOException { try (Repository repo = repoManager.openRepository(allUsersName); ObjectInserter oi = repo.newObjectInserter()) { if (repo.exactRef(RefNames.refsUsers(account.getId())) == null) { createUserBranch(repo, oi, committerIdent, authorIdent, account); } } } public static void createUserBranch(Repository repo, ObjectInserter oi, PersonIdent committerIdent, PersonIdent authorIdent, Account account) throws IOException { ObjectId id = createInitialEmptyCommit(oi, committerIdent, authorIdent, account.getRegisteredOn()); String refName = RefNames.refsUsers(account.getId()); RefUpdate ru = repo.updateRef(refName); ru.setExpectedOldObjectId(ObjectId.zeroId()); ru.setNewObjectId(id); ru.setForceUpdate(true); ru.setRefLogIdent(committerIdent); ru.setRefLogMessage("Create Account", true); Result result = ru.update(); if (result != Result.NEW) { throw new IOException(String.format("Failed to update ref %s: %s", refName, result.name())); } } private static ObjectId createInitialEmptyCommit(ObjectInserter oi, PersonIdent committerIdent, PersonIdent authorIdent, Timestamp registrationDate) throws IOException { CommitBuilder cb = new CommitBuilder(); cb.setTreeId(emptyTree(oi)); cb.setCommitter(new PersonIdent(committerIdent, registrationDate)); cb.setAuthor(new PersonIdent(authorIdent, registrationDate)); cb.setMessage("Create Account"); ObjectId id = oi.insert(cb); oi.flush(); return id; } private static ObjectId emptyTree(ObjectInserter oi) throws IOException { return oi.insert(Constants.OBJ_TREE, new byte[] {}); } private void deleteUserBranch(Account.Id accountId) throws IOException { try (Repository repo = repoManager.openRepository(allUsersName)) { deleteUserBranch(repo, committerIdent, accountId); } } public static void deleteUserBranch(Repository repo, PersonIdent refLogIdent, Account.Id accountId) throws IOException { String refName = RefNames.refsUsers(accountId); Ref ref = repo.exactRef(refName); if (ref == null) { return; } RefUpdate ru = repo.updateRef(refName); ru.setExpectedOldObjectId(ref.getObjectId()); ru.setNewObjectId(ObjectId.zeroId()); ru.setForceUpdate(true); ru.setRefLogIdent(refLogIdent); ru.setRefLogMessage("Delete Account", true); Result result = ru.delete(); if (result != Result.FORCED) { throw new IOException(String.format("Failed to delete ref %s: %s", refName, result.name())); } } }