src/main/java/com/google/gerrit/pgm/ImportGerrit1.java - gerrit - Git at Google

 // Copyright (C) 2008 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.pgm;

 import com.google.gerrit.client.reviewdb.Account;
 import com.google.gerrit.client.reviewdb.AccountGroup;
 import com.google.gerrit.client.reviewdb.AccountGroupMember;
 import com.google.gerrit.client.reviewdb.ApprovalCategory;
 import com.google.gerrit.client.reviewdb.Change;
 import com.google.gerrit.client.reviewdb.ChangeApproval;
 import com.google.gerrit.client.reviewdb.PatchSet;
 import com.google.gerrit.client.reviewdb.Project;
 import com.google.gerrit.client.reviewdb.ProjectRight;
 import com.google.gerrit.client.reviewdb.ReviewDb;
 import com.google.gerrit.client.reviewdb.SystemConfig;
 import com.google.gerrit.client.rpc.Common;
 import com.google.gerrit.git.InvalidRepositoryException;
 import com.google.gerrit.git.PatchSetImporter;
 import com.google.gerrit.git.WorkQueue;
 import com.google.gerrit.server.ChangeUtil;
 import com.google.gerrit.server.GerritServer;
 import com.google.gwtjsonrpc.server.XsrfException;
 import com.google.gwtorm.client.OrmException;
 import com.google.gwtorm.jdbc.JdbcSchema;

 import org.spearce.jgit.lib.Constants;
 import org.spearce.jgit.lib.LockFile;
 import org.spearce.jgit.lib.ObjectId;
 import org.spearce.jgit.lib.ProgressMonitor;
 import org.spearce.jgit.lib.Ref;
 import org.spearce.jgit.lib.RefUpdate;
 import org.spearce.jgit.lib.Repository;
 import org.spearce.jgit.lib.TextProgressMonitor;
 import org.spearce.jgit.revwalk.RevCommit;
 import org.spearce.jgit.revwalk.RevWalk;

 import java.io.File;
 import java.io.IOException;
 import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.SQLException;
 import java.sql.Statement;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 /**
  * Imports data from Gerrit 1 into Gerrit 2.
  * <p>
  * The tool assumes that <code>gerrit1_import/import_gerrit1.sql</code> has
  * already been executed on this schema. All existing ProjectRight entities are
  * wiped from the database and generated from scratch.
  * <p>
  * The tool requires Gerrit 1 tables (<code>gerrit1.$table_name</code>) through
  * the same database connection as the ReviewDb schema is on.
  */
 public class ImportGerrit1 {
   private static GerritServer gs;
   private static ReviewDb db;
   private static Connection sql;
   private static ApprovalCategory verifyCategory;
   private static ApprovalCategory approveCategory;
   private static ApprovalCategory submitCategory;

   public static void main(final String[] argv) throws OrmException,
       XsrfException, IOException, SQLException, InvalidRepositoryException {
     try {
       mainImpl(argv);
     } finally {
       WorkQueue.terminate();
     }
   }

   private static void mainImpl(final String[] argv) throws OrmException,
       XsrfException, IOException, SQLException, InvalidRepositoryException {
     final ProgressMonitor pm = new TextProgressMonitor();
     gs = GerritServer.getInstance();
     db = Common.getSchemaFactory().open();
     sql = ((JdbcSchema) db).getConnection();
     try {
       verifyCategory = db.approvalCategories().byName("Verified");
       approveCategory = db.approvalCategories().byName("Code Review");
       submitCategory = db.approvalCategories().get(ApprovalCategory.SUBMIT);

       final Statement query = sql.createStatement();
       java.sql.ResultSet srcs;

       // Set project descriptions back into git
       //
       pm.start(1);
       pm.beginTask("Export project descriptions", ProgressMonitor.UNKNOWN);
       srcs = query.executeQuery("SELECT p.project_id FROM projects p");
       while (srcs.next()) {
         final Project.Id projectId = new Project.Id(srcs.getInt(1));
         if (ProjectRight.WILD_PROJECT.equals(projectId)) {
           continue;
         }
         final Project proj = db.projects().get(projectId);
         final Repository e;
         final LockFile f;

         e = gs.getRepositoryCache().get(proj.getName());
         f = new LockFile(new File(e.getDirectory(), "description"));
         if (f.lock()) {
           String d = proj.getDescription();
           if (d != null) {
             d = d.trim() + "\n";
           } else {
             d = "";
           }
           f.write(Constants.encode(d));
           f.commit();
         } else {
           throw new IOException("Cannot set description for " + proj.getName());
         }
         pm.update(1);
       }
       srcs.close();
       pm.endTask();

       // Convert the approval right data from projects.
       //
       pm.start(1);
       pm.beginTask("Import project rights", ProgressMonitor.UNKNOWN);
       query.executeUpdate("DELETE FROM project_rights");
       insertApprovalWildCard();
       insertAccessWildCard();
       srcs =
           query.executeQuery("SELECT p.project_id, r.ar_key"
               + " FROM gerrit1.project_code_reviews r, projects p"
               + " WHERE p.project_id = r.project_id");
       while (srcs.next()) {
         final Project.Id projectId = new Project.Id(srcs.getInt(1));
         final String arKey = srcs.getString(2);
         doImport(projectId, arKey);
         pm.update(1);
       }
       srcs.close();
       pm.endTask();

       // Compute the sort keys for change entities
       //
       srcs = query.executeQuery("SELECT change_id FROM changes");
       final ArrayList<Change.Id> changesToDo = new ArrayList<Change.Id>();
       while (srcs.next()) {
         final Change.Id changeId = new Change.Id(srcs.getInt(1));
         changesToDo.add(changeId);
       }
       srcs.close();
       pm.start(1);
       pm.beginTask("Compute sort keys", changesToDo.size());
       for (final Change.Id changeId : changesToDo) {
         final Change c = db.changes().get(changeId);
         ChangeUtil.computeSortKey(c);
         final List<ChangeApproval> approvals =
             db.changeApprovals().byChange(changeId).toList();
         for (final ChangeApproval a : approvals) {
           a.cache(c);
         }
         db.changeApprovals().update(approvals);
         db.changes().update(Collections.singleton(c));
         pm.update(1);
       }
       pm.endTask();

       // Rebuild the cached PatchSet information directly from Git.
       // There's some oddities in the Gerrit 1 data that we got from
       // Google App Engine's data store; the quickest way to fix it
       // is to just recache the data from Git.
       //
       srcs =
           query.executeQuery("SELECT change_id,patch_set_id FROM patch_sets");
       final ArrayList<PatchSet.Id> psToDo = new ArrayList<PatchSet.Id>();
       while (srcs.next()) {
         final Change.Id changeId = new Change.Id(srcs.getInt(1));
         final PatchSet.Id psId = new PatchSet.Id(changeId, srcs.getInt(2));
         psToDo.add(psId);
       }
       query.close();

       final Map<String, Set<String>> validRefs =
           new HashMap<String, Set<String>>();
       pm.start(1);
       pm.beginTask("Import patch sets", psToDo.size());
       for (final PatchSet.Id psId : psToDo) {
         final Change c = db.changes().get(psId.getParentKey());
         final PatchSet ps = db.patchSets().get(psId);
         final String projectName = c.getDest().getParentKey().get();
         final Repository repo = gs.getRepositoryCache().get(projectName);
         final RevWalk rw = new RevWalk(repo);
         final RevCommit src =
             rw.parseCommit(ObjectId.fromString(ps.getRevision().get()));
         new PatchSetImporter(db, repo, src, ps, false).run();
         Set<String> s = validRefs.get(projectName);
         if (s == null) {
           s = new HashSet<String>();
           validRefs.put(projectName, s);
         }
         s.add(ps.getRefName());
         pm.update(1);
       }
       pm.endTask();

       pruneProjectRefs(pm, validRefs);
     } finally {
       db.close();
     }
   }

   private static void pruneProjectRefs(final ProgressMonitor pm,
       final Map<String, Set<String>> validRefs) throws OrmException,
       IOException {
     final List<Project> pToClean = db.projects().all().toList();
     pm.start(1);
     pm.beginTask("Prune old refs", pToClean.size());
     for (final Project p : pToClean) {
       final Repository repo;
       try {
         repo = gs.getRepositoryCache().get(p.getName());
       } catch (InvalidRepositoryException e) {
         pm.update(1);
         continue;
       }

       Set<String> valid = validRefs.get(p.getName());
       if (valid == null) {
         valid = Collections.emptySet();
       }

       final RevWalk rw = new RevWalk(repo);
       for (final Ref r : repo.getAllRefs().values()) {
         boolean delete = false;
         if (r.getName().startsWith("refs/merges/")) {
           delete = true;
         }
         if (r.getName().startsWith("refs/changes/")
             && !valid.contains(r.getName())) {
           delete = true;
         }
         if (delete) {
           final RefUpdate u = repo.updateRef(r.getName());
           u.setForceUpdate(true);
           u.delete(rw);
         }
       }
       pm.update(1);
     }
     pm.endTask();
   }

   private static void insertApprovalWildCard() throws OrmException {
     final ProjectRight.Key key =
         new ProjectRight.Key(ProjectRight.WILD_PROJECT,
             approveCategory.getId(), db.systemConfig().get(
                 new SystemConfig.Key()).registeredGroupId);
     final ProjectRight pr = new ProjectRight(key);
     pr.setMinValue((short) -1);
     pr.setMaxValue((short) 1);
     db.projectRights().insert(Collections.singleton(pr));
   }

   private static void insertAccessWildCard() throws OrmException {
     final ProjectRight.Key key =
         new ProjectRight.Key(ProjectRight.WILD_PROJECT, ApprovalCategory.READ,
             db.systemConfig().get(new SystemConfig.Key()).anonymousGroupId);
     final ProjectRight pr = new ProjectRight(key);
     pr.setMinValue((short) 1);
     pr.setMaxValue((short) 1);
     db.projectRights().insert(Collections.singleton(pr));
   }

   private static void doImport(final Project.Id projectId, final String arKey)
       throws OrmException, SQLException {
     final int arId = findId(arKey);
     if (arId < 0) {
       return;
     }

     final Project proj = db.projects().get(projectId);
     final Set<AccountGroup.Id> approverg = groups(arId, "approver");
     final Set<AccountGroup.Id> verifierg = groups(arId, "verifier");
     final Set<AccountGroup.Id> submitterg = groups(arId, "submitter");

     final Set<Account.Id> approveru = users(arId, "approver");
     final Set<Account.Id> verifieru = users(arId, "verifier");
     final Set<Account.Id> submitteru = users(arId, "submitter");

     importCat(proj, "approvers", approveCategory, approverg, approveru);
     importCat(proj, "verifiers", verifyCategory, verifierg, verifieru);
     importCat(proj, "submitters", submitCategory, submitterg, submitteru);
   }

   private static void importCat(final Project proj, final String type,
       final ApprovalCategory category, final Set<AccountGroup.Id> groups,
       final Set<Account.Id> users) throws OrmException {
     final HashSet<Account.Id> needGroup = new HashSet<Account.Id>(users);
     for (final AccountGroup.Id groupId : groups) {
       insertRight(proj, category, groupId);
       for (final Iterator<Account.Id> i = needGroup.iterator(); i.hasNext();) {
         if (Common.getGroupCache().isInGroup(i.next(), groupId)) {
           i.remove();
         }
       }
     }

     if (!needGroup.isEmpty()) {
       final AccountGroup.Id groupId =
           new AccountGroup.Id(db.nextAccountGroupId());
       final AccountGroup group =
           new AccountGroup(new AccountGroup.NameKey(shortName(proj) + "_"
               + proj.getId().get() + "-" + type), groupId);
       group.setOwnerGroupId(proj.getOwnerGroupId());
       group.setDescription(proj.getName() + " " + type);
       db.accountGroups().insert(Collections.singleton(group));
       for (final Account.Id aId : needGroup) {
         db.accountGroupMembers().insert(
             Collections.singleton(new AccountGroupMember(
                 new AccountGroupMember.Key(aId, groupId))));
       }
       insertRight(proj, category, groupId);
     }
   }

   private static void insertRight(final Project proj,
       final ApprovalCategory category, final AccountGroup.Id groupId)
       throws OrmException {
     final ProjectRight.Key key =
         new ProjectRight.Key(proj.getId(), category.getId(), groupId);
     final ProjectRight pr = new ProjectRight(key);
     if (category == approveCategory) {
       pr.setMinValue((short) -2);
       pr.setMaxValue((short) 2);
     } else if (category == verifyCategory) {
       pr.setMinValue((short) -1);
       pr.setMaxValue((short) 1);
     } else if (category == submitCategory) {
       pr.setMinValue((short) 1);
       pr.setMaxValue((short) 1);
     } else {
       throw new OrmException("Cannot import category " + category.getId());
     }
     db.projectRights().insert(Collections.singleton(pr));
   }

   private static String shortName(final Project proj) {
     final String n = proj.getName();
     final int s = n.lastIndexOf('/');
     return 0 < s ? n.substring(s + 1) : n;
   }

   private static Set<AccountGroup.Id> groups(final int arId, final String type)
       throws SQLException {
     final PreparedStatement ps =
         sql.prepareStatement("SELECT g.group_id FROM account_groups g,"
             + " gerrit1.approval_right_groups s, gerrit1.account_groups o"
             + " WHERE s.ar_id = ? AND s.type = ?"
             + " AND o.gae_key = s.group_key AND (g.name = o.name"
             + " OR (g.name = 'Administrators' AND o.name = 'admin'))");
     try {
       ps.setInt(1, arId);
       ps.setString(2, type);
       final java.sql.ResultSet rs = ps.executeQuery();
       try {
         final HashSet<AccountGroup.Id> r = new HashSet<AccountGroup.Id>();
         while (rs.next()) {
           r.add(new AccountGroup.Id(rs.getInt(1)));
         }
         return r;
       } finally {
         rs.close();
       }
     } finally {
       ps.close();
     }
   }

   private static Set<Account.Id> users(final int arId, final String type)
       throws SQLException {
     final PreparedStatement ps =
         sql.prepareStatement("SELECT a.account_id FROM accounts a,"
             + " gerrit1.approval_right_users s"
             + " WHERE s.ar_id = ? AND s.type = ?"
             + " AND a.preferred_email = s.email");
     try {
       ps.setInt(1, arId);
       ps.setString(2, type);
       final java.sql.ResultSet rs = ps.executeQuery();
       try {
         final HashSet<Account.Id> r = new HashSet<Account.Id>();
         while (rs.next()) {
           r.add(new Account.Id(rs.getInt(1)));
         }
         return r;
       } finally {
         rs.close();
       }
     } finally {
       ps.close();
     }
   }

   private static int findId(final String arKey) throws SQLException {
     final PreparedStatement ps =
         sql.prepareStatement("SELECT ar_id FROM gerrit1.approval_rights"
             + " WHERE gae_key=?");
     try {
       ps.setString(1, arKey);
       final java.sql.ResultSet rs = ps.executeQuery();
       try {
         if (rs.next()) {
           return rs.getInt(1);
         }
         return -1;
       } finally {
         rs.close();
       }
     } finally {
       ps.close();
     }
   }
 }
	// Copyright (C) 2008 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.pgm;

	import com.google.gerrit.client.reviewdb.Account;
	import com.google.gerrit.client.reviewdb.AccountGroup;
	import com.google.gerrit.client.reviewdb.AccountGroupMember;
	import com.google.gerrit.client.reviewdb.ApprovalCategory;
	import com.google.gerrit.client.reviewdb.Change;
	import com.google.gerrit.client.reviewdb.ChangeApproval;
	import com.google.gerrit.client.reviewdb.PatchSet;
	import com.google.gerrit.client.reviewdb.Project;
	import com.google.gerrit.client.reviewdb.ProjectRight;
	import com.google.gerrit.client.reviewdb.ReviewDb;
	import com.google.gerrit.client.reviewdb.SystemConfig;
	import com.google.gerrit.client.rpc.Common;
	import com.google.gerrit.git.InvalidRepositoryException;
	import com.google.gerrit.git.PatchSetImporter;
	import com.google.gerrit.git.WorkQueue;
	import com.google.gerrit.server.ChangeUtil;
	import com.google.gerrit.server.GerritServer;
	import com.google.gwtjsonrpc.server.XsrfException;
	import com.google.gwtorm.client.OrmException;
	import com.google.gwtorm.jdbc.JdbcSchema;

	import org.spearce.jgit.lib.Constants;
	import org.spearce.jgit.lib.LockFile;
	import org.spearce.jgit.lib.ObjectId;
	import org.spearce.jgit.lib.ProgressMonitor;
	import org.spearce.jgit.lib.Ref;
	import org.spearce.jgit.lib.RefUpdate;
	import org.spearce.jgit.lib.Repository;
	import org.spearce.jgit.lib.TextProgressMonitor;
	import org.spearce.jgit.revwalk.RevCommit;
	import org.spearce.jgit.revwalk.RevWalk;

	import java.io.File;
	import java.io.IOException;
	import java.sql.Connection;
	import java.sql.PreparedStatement;
	import java.sql.SQLException;
	import java.sql.Statement;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;

	/**
	* Imports data from Gerrit 1 into Gerrit 2.
	* <p>
	* The tool assumes that <code>gerrit1_import/import_gerrit1.sql</code> has
	* already been executed on this schema. All existing ProjectRight entities are
	* wiped from the database and generated from scratch.
	* <p>
	* The tool requires Gerrit 1 tables (<code>gerrit1.$table_name</code>) through
	* the same database connection as the ReviewDb schema is on.
	*/
	public class ImportGerrit1 {
	private static GerritServer gs;
	private static ReviewDb db;
	private static Connection sql;
	private static ApprovalCategory verifyCategory;
	private static ApprovalCategory approveCategory;
	private static ApprovalCategory submitCategory;

	public static void main(final String[] argv) throws OrmException,
	XsrfException, IOException, SQLException, InvalidRepositoryException {
	try {
	mainImpl(argv);
	} finally {
	WorkQueue.terminate();
	}
	}

	private static void mainImpl(final String[] argv) throws OrmException,
	XsrfException, IOException, SQLException, InvalidRepositoryException {
	final ProgressMonitor pm = new TextProgressMonitor();
	gs = GerritServer.getInstance();
	db = Common.getSchemaFactory().open();
	sql = ((JdbcSchema) db).getConnection();
	try {
	verifyCategory = db.approvalCategories().byName("Verified");
	approveCategory = db.approvalCategories().byName("Code Review");
	submitCategory = db.approvalCategories().get(ApprovalCategory.SUBMIT);

	final Statement query = sql.createStatement();
	java.sql.ResultSet srcs;

	// Set project descriptions back into git
	//
	pm.start(1);
	pm.beginTask("Export project descriptions", ProgressMonitor.UNKNOWN);
	srcs = query.executeQuery("SELECT p.project_id FROM projects p");
	while (srcs.next()) {
	final Project.Id projectId = new Project.Id(srcs.getInt(1));
	if (ProjectRight.WILD_PROJECT.equals(projectId)) {
	continue;
	}
	final Project proj = db.projects().get(projectId);
	final Repository e;
	final LockFile f;

	e = gs.getRepositoryCache().get(proj.getName());
	f = new LockFile(new File(e.getDirectory(), "description"));
	if (f.lock()) {
	String d = proj.getDescription();
	if (d != null) {
	d = d.trim() + "\n";
	} else {
	d = "";
	}
	f.write(Constants.encode(d));
	f.commit();
	} else {
	throw new IOException("Cannot set description for " + proj.getName());
	}
	pm.update(1);
	}
	srcs.close();
	pm.endTask();

	// Convert the approval right data from projects.
	//
	pm.start(1);
	pm.beginTask("Import project rights", ProgressMonitor.UNKNOWN);
	query.executeUpdate("DELETE FROM project_rights");
	insertApprovalWildCard();
	insertAccessWildCard();
	srcs =
	query.executeQuery("SELECT p.project_id, r.ar_key"
	+ " FROM gerrit1.project_code_reviews r, projects p"
	+ " WHERE p.project_id = r.project_id");
	while (srcs.next()) {
	final Project.Id projectId = new Project.Id(srcs.getInt(1));
	final String arKey = srcs.getString(2);
	doImport(projectId, arKey);
	pm.update(1);
	}
	srcs.close();
	pm.endTask();

	// Compute the sort keys for change entities
	//
	srcs = query.executeQuery("SELECT change_id FROM changes");
	final ArrayList<Change.Id> changesToDo = new ArrayList<Change.Id>();
	while (srcs.next()) {
	final Change.Id changeId = new Change.Id(srcs.getInt(1));
	changesToDo.add(changeId);
	}
	srcs.close();
	pm.start(1);
	pm.beginTask("Compute sort keys", changesToDo.size());
	for (final Change.Id changeId : changesToDo) {
	final Change c = db.changes().get(changeId);
	ChangeUtil.computeSortKey(c);
	final List<ChangeApproval> approvals =
	db.changeApprovals().byChange(changeId).toList();
	for (final ChangeApproval a : approvals) {
	a.cache(c);
	}
	db.changeApprovals().update(approvals);
	db.changes().update(Collections.singleton(c));
	pm.update(1);
	}
	pm.endTask();

	// Rebuild the cached PatchSet information directly from Git.
	// There's some oddities in the Gerrit 1 data that we got from
	// Google App Engine's data store; the quickest way to fix it
	// is to just recache the data from Git.
	//
	srcs =
	query.executeQuery("SELECT change_id,patch_set_id FROM patch_sets");
	final ArrayList<PatchSet.Id> psToDo = new ArrayList<PatchSet.Id>();
	while (srcs.next()) {
	final Change.Id changeId = new Change.Id(srcs.getInt(1));
	final PatchSet.Id psId = new PatchSet.Id(changeId, srcs.getInt(2));
	psToDo.add(psId);
	}
	query.close();

	final Map<String, Set<String>> validRefs =
	new HashMap<String, Set<String>>();
	pm.start(1);
	pm.beginTask("Import patch sets", psToDo.size());
	for (final PatchSet.Id psId : psToDo) {
	final Change c = db.changes().get(psId.getParentKey());
	final PatchSet ps = db.patchSets().get(psId);
	final String projectName = c.getDest().getParentKey().get();
	final Repository repo = gs.getRepositoryCache().get(projectName);
	final RevWalk rw = new RevWalk(repo);
	final RevCommit src =
	rw.parseCommit(ObjectId.fromString(ps.getRevision().get()));
	new PatchSetImporter(db, repo, src, ps, false).run();
	Set<String> s = validRefs.get(projectName);
	if (s == null) {
	s = new HashSet<String>();
	validRefs.put(projectName, s);
	}
	s.add(ps.getRefName());
	pm.update(1);
	}
	pm.endTask();

	pruneProjectRefs(pm, validRefs);
	} finally {
	db.close();
	}
	}

	private static void pruneProjectRefs(final ProgressMonitor pm,
	final Map<String, Set<String>> validRefs) throws OrmException,
	IOException {
	final List<Project> pToClean = db.projects().all().toList();
	pm.start(1);
	pm.beginTask("Prune old refs", pToClean.size());
	for (final Project p : pToClean) {
	final Repository repo;
	try {
	repo = gs.getRepositoryCache().get(p.getName());
	} catch (InvalidRepositoryException e) {
	pm.update(1);
	continue;
	}

	Set<String> valid = validRefs.get(p.getName());
	if (valid == null) {
	valid = Collections.emptySet();
	}

	final RevWalk rw = new RevWalk(repo);
	for (final Ref r : repo.getAllRefs().values()) {
	boolean delete = false;
	if (r.getName().startsWith("refs/merges/")) {
	delete = true;
	}
	if (r.getName().startsWith("refs/changes/")
	&& !valid.contains(r.getName())) {
	delete = true;
	}
	if (delete) {
	final RefUpdate u = repo.updateRef(r.getName());
	u.setForceUpdate(true);
	u.delete(rw);
	}
	}
	pm.update(1);
	}
	pm.endTask();
	}

	private static void insertApprovalWildCard() throws OrmException {
	final ProjectRight.Key key =
	new ProjectRight.Key(ProjectRight.WILD_PROJECT,
	approveCategory.getId(), db.systemConfig().get(
	new SystemConfig.Key()).registeredGroupId);
	final ProjectRight pr = new ProjectRight(key);
	pr.setMinValue((short) -1);
	pr.setMaxValue((short) 1);
	db.projectRights().insert(Collections.singleton(pr));
	}

	private static void insertAccessWildCard() throws OrmException {
	final ProjectRight.Key key =
	new ProjectRight.Key(ProjectRight.WILD_PROJECT, ApprovalCategory.READ,
	db.systemConfig().get(new SystemConfig.Key()).anonymousGroupId);
	final ProjectRight pr = new ProjectRight(key);
	pr.setMinValue((short) 1);
	pr.setMaxValue((short) 1);
	db.projectRights().insert(Collections.singleton(pr));
	}

	private static void doImport(final Project.Id projectId, final String arKey)
	throws OrmException, SQLException {
	final int arId = findId(arKey);
	if (arId < 0) {
	return;
	}

	final Project proj = db.projects().get(projectId);
	final Set<AccountGroup.Id> approverg = groups(arId, "approver");
	final Set<AccountGroup.Id> verifierg = groups(arId, "verifier");
	final Set<AccountGroup.Id> submitterg = groups(arId, "submitter");

	final Set<Account.Id> approveru = users(arId, "approver");
	final Set<Account.Id> verifieru = users(arId, "verifier");
	final Set<Account.Id> submitteru = users(arId, "submitter");

	importCat(proj, "approvers", approveCategory, approverg, approveru);
	importCat(proj, "verifiers", verifyCategory, verifierg, verifieru);
	importCat(proj, "submitters", submitCategory, submitterg, submitteru);
	}

	private static void importCat(final Project proj, final String type,
	final ApprovalCategory category, final Set<AccountGroup.Id> groups,
	final Set<Account.Id> users) throws OrmException {
	final HashSet<Account.Id> needGroup = new HashSet<Account.Id>(users);
	for (final AccountGroup.Id groupId : groups) {
	insertRight(proj, category, groupId);
	for (final Iterator<Account.Id> i = needGroup.iterator(); i.hasNext();) {
	if (Common.getGroupCache().isInGroup(i.next(), groupId)) {
	i.remove();
	}
	}
	}

	if (!needGroup.isEmpty()) {
	final AccountGroup.Id groupId =
	new AccountGroup.Id(db.nextAccountGroupId());
	final AccountGroup group =
	new AccountGroup(new AccountGroup.NameKey(shortName(proj) + "_"
	+ proj.getId().get() + "-" + type), groupId);
	group.setOwnerGroupId(proj.getOwnerGroupId());
	group.setDescription(proj.getName() + " " + type);
	db.accountGroups().insert(Collections.singleton(group));
	for (final Account.Id aId : needGroup) {
	db.accountGroupMembers().insert(
	Collections.singleton(new AccountGroupMember(
	new AccountGroupMember.Key(aId, groupId))));
	}
	insertRight(proj, category, groupId);
	}
	}

	private static void insertRight(final Project proj,
	final ApprovalCategory category, final AccountGroup.Id groupId)
	throws OrmException {
	final ProjectRight.Key key =
	new ProjectRight.Key(proj.getId(), category.getId(), groupId);
	final ProjectRight pr = new ProjectRight(key);
	if (category == approveCategory) {
	pr.setMinValue((short) -2);
	pr.setMaxValue((short) 2);
	} else if (category == verifyCategory) {
	pr.setMinValue((short) -1);
	pr.setMaxValue((short) 1);
	} else if (category == submitCategory) {
	pr.setMinValue((short) 1);
	pr.setMaxValue((short) 1);
	} else {
	throw new OrmException("Cannot import category " + category.getId());
	}
	db.projectRights().insert(Collections.singleton(pr));
	}

	private static String shortName(final Project proj) {
	final String n = proj.getName();
	final int s = n.lastIndexOf('/');
	return 0 < s ? n.substring(s + 1) : n;
	}

	private static Set<AccountGroup.Id> groups(final int arId, final String type)
	throws SQLException {
	final PreparedStatement ps =
	sql.prepareStatement("SELECT g.group_id FROM account_groups g,"
	+ " gerrit1.approval_right_groups s, gerrit1.account_groups o"
	+ " WHERE s.ar_id = ? AND s.type = ?"
	+ " AND o.gae_key = s.group_key AND (g.name = o.name"
	+ " OR (g.name = 'Administrators' AND o.name = 'admin'))");
	try {
	ps.setInt(1, arId);
	ps.setString(2, type);
	final java.sql.ResultSet rs = ps.executeQuery();
	try {
	final HashSet<AccountGroup.Id> r = new HashSet<AccountGroup.Id>();
	while (rs.next()) {
	r.add(new AccountGroup.Id(rs.getInt(1)));
	}
	return r;
	} finally {
	rs.close();
	}
	} finally {
	ps.close();
	}
	}

	private static Set<Account.Id> users(final int arId, final String type)
	throws SQLException {
	final PreparedStatement ps =
	sql.prepareStatement("SELECT a.account_id FROM accounts a,"
	+ " gerrit1.approval_right_users s"
	+ " WHERE s.ar_id = ? AND s.type = ?"
	+ " AND a.preferred_email = s.email");
	try {
	ps.setInt(1, arId);
	ps.setString(2, type);
	final java.sql.ResultSet rs = ps.executeQuery();
	try {
	final HashSet<Account.Id> r = new HashSet<Account.Id>();
	while (rs.next()) {
	r.add(new Account.Id(rs.getInt(1)));
	}
	return r;
	} finally {
	rs.close();
	}
	} finally {
	ps.close();
	}
	}

	private static int findId(final String arKey) throws SQLException {
	final PreparedStatement ps =
	sql.prepareStatement("SELECT ar_id FROM gerrit1.approval_rights"
	+ " WHERE gae_key=?");
	try {
	ps.setString(1, arKey);
	final java.sql.ResultSet rs = ps.executeQuery();
	try {
	if (rs.next()) {
	return rs.getInt(1);
	}
	return -1;
	} finally {
	rs.close();
	}
	} finally {
	ps.close();
	}
	}
	}