import org.eclipse.jgit.internal.storage.dfs.DfsRepositoryDescription; //导入依赖的package包/类
@Override
public Repository open(DaemonClient client, String name)
        throws RepositoryNotFoundException,
        ServiceNotAuthorizedException, ServiceNotEnabledException,
        ServiceMayNotContinueException {
    CassandraRepository repo = repositories.get(name);
    if (repo == null) {
        try {
            repo = new CassandraRepository(
                    new DfsRepositoryDescription(sanitiseName(name)),
                    storeconn);
        } catch (Exception e) {
            throw new ServiceMayNotContinueException(e);
        }
        repositories.put(name, repo);
    }
    return repo;
}
 

import org.eclipse.jgit.internal.storage.dfs.DfsRepositoryDescription; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
  TestKey key1 = validKeyWithoutExpiration();
  TestKey key3 = expiredKey();
  repo = new InMemoryRepository(new DfsRepositoryDescription("repo"));
  store = new PublicKeyStore(repo);
  store.add(key1.getPublicKeyRing());
  store.add(key3.getPublicKeyRing());

  PersonIdent ident = new PersonIdent("A U Thor", "[email protected]");
  CommitBuilder cb = new CommitBuilder();
  cb.setAuthor(ident);
  cb.setCommitter(ident);
  assertEquals(RefUpdate.Result.NEW, store.save(cb));

  signedPushConfig = new SignedPushConfig();
  signedPushConfig.setCertNonceSeed("sekret");
  signedPushConfig.setCertNonceSlopLimit(60 * 24);
  checker = newChecker(true);
}
 

import org.eclipse.jgit.internal.storage.dfs.DfsRepositoryDescription; //导入依赖的package包/类
@SafeVarargs
private static BatchRefUpdate newBatchRefUpdate(Consumer<ReceiveCommand>... resultSetters) {
  try (Repository repo = new InMemoryRepository(new DfsRepositoryDescription("repo"))) {
    BatchRefUpdate bru = repo.getRefDatabase().newBatchUpdate();
    for (int i = 0; i < resultSetters.length; i++) {
      ReceiveCommand cmd =
          new ReceiveCommand(
              ObjectId.fromString(String.format("%039x1", i)),
              ObjectId.fromString(String.format("%039x2", i)),
              "refs/heads/branch" + i);
      bru.addCommand(cmd);
      resultSetters[i].accept(cmd);
    }
    return bru;
  }
}
 

import org.eclipse.jgit.internal.storage.dfs.DfsRepositoryDescription; //导入依赖的package包/类
Repository openUncached(GitRepository repo, boolean mustExist) throws IOException {
  String objectPath = repo.getObjectPath();

  // ByteString suffix = ZERO.concat(ByteString.copyFromUtf8(absolutePath)).concat(ZERO);
  // KeyValuePath refsPath = refsBase.child(suffix);

  DfsRepositoryDescription description = new DfsRepositoryDescription(objectPath);
  ObjectStorePath repoPath = new ObjectStorePath(objectStore, objectPath);
  CloudDfsRepository dfs = new CloudDfsRepository(repo.getData(), description, repoPath, dataStore, tempDir);

  try {
    if (!dfs.exists()) {
      if (mustExist) {
        throw new RepositoryNotFoundException(repo.getData().getName());
      }
      dfs.create(true);
      dfs.updateRef(Constants.HEAD).link("refs/heads/master");
    }
  } catch (IOException e) {
    throw new IllegalStateException("Error creating repository", e);
  }

  dfs.getConfig().setBoolean("http", null, "receivepack", true);

  return dfs;
}
 

import org.eclipse.jgit.internal.storage.dfs.DfsRepositoryDescription; //导入依赖的package包/类
public RepositoryS3Test() {
    try {
        this.repository = new TestRepository<>(new InMemoryRepository(new DfsRepositoryDescription()));
        this.uut = new RepositoryS3(BUCKET, repository.getRepository(), amazonS3, new Branch(Constants.MASTER));
    }
    catch (Exception e) {
        throw new IllegalArgumentException(e);
    }
}
 

import org.eclipse.jgit.internal.storage.dfs.DfsRepositoryDescription; //导入依赖的package包/类
/**
 * Creating a new repository object may result in creating a new repository
 * in the storage layer, or if the repository identified by "repoDesc" already
 * exists, it will be used instead.
 *
 * @param repoDesc  description of the repository that this object will
 *                  provide access to.
 */
@SuppressWarnings("rawtypes")
public CassandraRepository(DfsRepositoryDescription repoDesc, StoreConnection conn)
        throws IOException {
    super(new DfsRepositoryBuilder<DfsRepositoryBuilder, CassandraRepository>() {
        @Override
        public CassandraRepository build() throws IOException {
            throw new UnsupportedOperationException();
        }
    }.setRepositoryDescription(repoDesc));

    objdb = new CassandraObjDatabase(this, conn);
    refdb = new CassandraRefDatabase(this, conn);
}
 

import org.eclipse.jgit.internal.storage.dfs.DfsRepositoryDescription; //导入依赖的package包/类
/**
 * Constructor
 *
 * @param keyspace the Cassandra keyspace
 * @param session  a Cassandra session instance
 * @throws NullPointerException if either of the parameters are null
 * @throws IOException          if an exception occurs when communicating to the
 *                              database
 */
public ObjStore(String keyspace, Session session,
                DfsRepositoryDescription repoDesc) throws IOException {
    if (keyspace == null || session == null) {
        throw new NullPointerException();
    }
    this.keyspace = keyspace;
    this.session = session;
    this.repoDesc = repoDesc;
    createSchemaIfNotExist();
}
 

import org.eclipse.jgit.internal.storage.dfs.DfsRepositoryDescription; //导入依赖的package包/类
public static TestRepository<InMemoryRepository> cloneProject(Project.NameKey project, String uri)
    throws Exception {
  DfsRepositoryDescription desc = new DfsRepositoryDescription("clone of " + project.get());

  FS fs = FS.detect();

  // Avoid leaking user state into our tests.
  fs.setUserHome(null);

  InMemoryRepository dest =
      new InMemoryRepository.Builder()
          .setRepositoryDescription(desc)
          // SshTransport depends on a real FS to read ~/.ssh/config, but
          // InMemoryRepository by default uses a null FS.
          // TODO(dborowitz): Remove when we no longer depend on SSH.
          .setFS(fs)
          .build();
  Config cfg = dest.getConfig();
  cfg.setString("remote", "origin", "url", uri);
  cfg.setString("remote", "origin", "fetch", "+refs/heads/*:refs/remotes/origin/*");
  TestRepository<InMemoryRepository> testRepo = newTestRepository(dest);
  FetchResult result = testRepo.git().fetch().setRemote("origin").call();
  String originMaster = "refs/remotes/origin/master";
  if (result.getTrackingRefUpdate(originMaster) != null) {
    testRepo.reset(originMaster);
  }
  return testRepo;
}
 

import org.eclipse.jgit.internal.storage.dfs.DfsRepositoryDescription; //导入依赖的package包/类
@Override
protected void setUp() throws Exception {
  repo = new TestRepository<DfsRepository>(
      new InMemoryRepository(new DfsRepositoryDescription("test")));
  parser = new RevisionParser(
      repo.getRepository(),
      new TestGitilesAccess(repo.getRepository()).forRequest(null),
      new VisibilityCache(false, CacheBuilder.newBuilder().maximumSize(0)));
}
 

import org.eclipse.jgit.internal.storage.dfs.DfsRepositoryDescription; //导入依赖的package包/类
@Override
protected void setUp() throws Exception {
  repo = new TestRepository<DfsRepository>(
      new InMemoryRepository(new DfsRepositoryDescription("test")));
  servlet = new RepositoryIndexServlet(
      new DefaultRenderer(),
      new TestGitilesAccess(repo.getRepository()),
      new TimeCache());
}
 

import org.eclipse.jgit.internal.storage.dfs.DfsRepositoryDescription; //导入依赖的package包/类
@Override
protected void setUp() throws Exception {
  repo = new TestRepository<DfsRepository>(
      new InMemoryRepository(new DfsRepositoryDescription("test")));
  walk = new RevWalk(repo.getRepository());
  cache = new TimeCache();
  start = repo.getClock().getTime() / 1000;
}
 

import org.eclipse.jgit.internal.storage.dfs.DfsRepositoryDescription; //导入依赖的package包/类
@Override
protected void setUp() throws Exception {
  DfsRepository r = new InMemoryRepository(new DfsRepositoryDescription("test"));
  repo = new TestRepository<DfsRepository>(r);

  RevCommit commit = repo.branch("refs/heads/master").commit().create();
  repo.update("refs/heads/branch", commit);
  repo.update("refs/tags/ctag", commit);
  RevTag tag = repo.tag("atag", commit);
  repo.update("refs/tags/atag", tag);
  r.updateRef("HEAD").link("refs/heads/master");

  servlet = TestGitilesServlet.create(repo);
}
 

import org.eclipse.jgit.internal.storage.dfs.DfsRepositoryDescription; //导入依赖的package包/类
public CloudDfsRepository(RepositoryData data, DfsRepositoryDescription repoDesc, ObjectStorePath repoPath,
    DataStore dataStore, File tempDir) {
  super(new DfsRepositoryBuilder<DfsRepositoryBuilder, CloudDfsRepository>() {
    @Override
    public CloudDfsRepository build() throws IOException {
      throw new UnsupportedOperationException();
    }
  }.setRepositoryDescription(repoDesc));
  this.data = data;

  this.objdb = new CloudObjDatabase(this, repoPath, tempDir);
  this.refdb = new CloudRefDatabase(this, dataStore);
}
 

import org.eclipse.jgit.internal.storage.dfs.DfsRepositoryDescription; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    desc = new DfsPackDescription(new DfsRepositoryDescription(), DESC_NAME);
}
 

import org.eclipse.jgit.internal.storage.dfs.DfsRepositoryDescription; //导入依赖的package包/类
@Nonnull
public static GfsConfiguration inMemoryRepo() {
  return repo(new InMemoryRepository(new DfsRepositoryDescription()));
}
 

import org.eclipse.jgit.internal.storage.dfs.DfsRepositoryDescription; //导入依赖的package包/类
public TestRepository(boolean bare) {
  super(new DfsRepositoryDescription());
  File mockLocation = new File(System.getProperty("java.io.tmpdir"));
  directory = bare ? mockLocation : new File(mockLocation, DOT_GIT);
  workTree = bare ? null : mockLocation;
}
 

import org.eclipse.jgit.internal.storage.dfs.DfsRepositoryDescription; //导入依赖的package包/类
@Before
public void setUp() {
  repo = new InMemoryRepository(new DfsRepositoryDescription("repo"));
  store = new PublicKeyStore(repo);
}
 

import org.eclipse.jgit.internal.storage.dfs.DfsRepositoryDescription; //导入依赖的package包/类
@Before
public void setUpInjector() throws Exception {
  Config cfg = InMemoryModule.newDefaultConfig();
  cfg.setInt("receive", null, "maxTrustDepth", 2);
  cfg.setStringList(
      "receive",
      null,
      "trustedKey",
      ImmutableList.of(
          Fingerprint.toString(keyB().getPublicKey().getFingerprint()),
          Fingerprint.toString(keyD().getPublicKey().getFingerprint())));
  Injector injector =
      Guice.createInjector(new InMemoryModule(cfg, NoteDbMode.newNotesMigrationFromEnv()));

  lifecycle = new LifecycleManager();
  lifecycle.add(injector);
  injector.injectMembers(this);
  lifecycle.start();

  db = schemaFactory.open();
  schemaCreator.create(db);
  userId = accountManager.authenticate(AuthRequest.forUser("user")).getAccountId();
  // Note: does not match any key in TestKeys.
  accountsUpdate.create().update(userId, a -> a.setPreferredEmail("[email protected]"));
  user = reloadUser();

  requestContext.setContext(
      new RequestContext() {
        @Override
        public CurrentUser getUser() {
          return user;
        }

        @Override
        public Provider<ReviewDb> getReviewDbProvider() {
          return Providers.of(db);
        }
      });

  storeRepo = new InMemoryRepository(new DfsRepositoryDescription("repo"));
  store = new PublicKeyStore(storeRepo);
}
 

import org.eclipse.jgit.internal.storage.dfs.DfsRepositoryDescription; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
  tr = new TestRepository<>(new InMemoryRepository(new DfsRepositoryDescription("pubkeys")));
  store = new PublicKeyStore(tr.getRepository());
}
 

import org.eclipse.jgit.internal.storage.dfs.DfsRepositoryDescription; //导入依赖的package包/类
@Before
public void setUp() {
  TestTimeUtil.resetWithClockStep(1, TimeUnit.SECONDS);
  project = new Project.NameKey("repo");
  repo = new InMemoryRepository(new DfsRepositoryDescription(project.get()));
}