import com.google.gwtorm.server.SchemaFactory; //导入依赖的package包/类
@Inject
public CreateBatchUser(@PluginName String pluginName, SchemaFactory<ReviewDb> schema,
					   PluginConfigFactory configFactory, SshKeyCache sshKeyCache, VersionedAuthorizedKeys.Accessor authorizedKeys,
					   AccountCache accountCache, AccountByEmailCache byEmailCache, AccountLoader.Factory infoLoader,
					   GroupsCollection groupsCollection, WorkQueue queue, ThreadLocalRequestContext context,
					   IdentifiedUser.GenericFactory userFactory) {
	this.schema = schema;
	this.sshKeyCache = sshKeyCache;
	this.authorizedKeys = authorizedKeys;
	this.accountCache = accountCache;
	this.byEmailCache = byEmailCache;
	this.infoLoader = infoLoader;
	this.groupsCollection = groupsCollection;
	this.context = context;
	this.userFactory = userFactory;
	pluginConfig = configFactory.getFromGerritConfig(pluginName);
	username = pluginConfig.getString("username", "jenkins");
	sshKey = pluginConfig.getString("sshKey");
	name = pluginConfig.getString("name", "Batch user");
	executor = queue.getDefaultQueue();

	createBatchUserIfNotExistsYet();
}
 

import com.google.gwtorm.server.SchemaFactory; //导入依赖的package包/类
@Inject
AccountCreator(
    SchemaFactory<ReviewDb> schema,
    Sequences sequences,
    AccountsUpdate.Server accountsUpdate,
    VersionedAuthorizedKeys.Accessor authorizedKeys,
    GroupCache groupCache,
    @ServerInitiated Provider<GroupsUpdate> groupsUpdateProvider,
    SshKeyCache sshKeyCache,
    ExternalIdsUpdate.Server externalIdsUpdate,
    @SshEnabled boolean sshEnabled) {
  accounts = new HashMap<>();
  reviewDbProvider = schema;
  this.sequences = sequences;
  this.accountsUpdate = accountsUpdate;
  this.authorizedKeys = authorizedKeys;
  this.groupCache = groupCache;
  this.groupsUpdateProvider = groupsUpdateProvider;
  this.sshKeyCache = sshKeyCache;
  this.externalIdsUpdate = externalIdsUpdate;
  this.sshEnabled = sshEnabled;
}
 

import com.google.gwtorm.server.SchemaFactory; //导入依赖的package包/类
Context(
    SchemaFactory<ReviewDb> schemaFactory,
    IdentifiedUser.GenericFactory userFactory,
    Account.Id accountId,
    Project.NameKey project) {
  this.schemaFactory = schemaFactory;
  this.userFactory = userFactory;
  this.accountId = accountId;
  this.project = project;
  map = new HashMap<>();
  cleanup = new RequestCleanup();
  map.put(DB_KEY, new RequestScopedReviewDbProvider(schemaFactory, Providers.of(cleanup)));
  map.put(RC_KEY, cleanup);

  IdentifiedUser user = userFactory.create(accountId);
  user.setAccessPath(AccessPath.GIT);
  map.put(USER_KEY, user);
}
 

import com.google.gwtorm.server.SchemaFactory; //导入依赖的package包/类
@Inject
CommandFactoryProvider(
    @CommandName(Commands.ROOT) DispatchCommandProvider d,
    @GerritServerConfig Config cfg,
    WorkQueue workQueue,
    SshLog l,
    SshScope s,
    SchemaFactory<ReviewDb> sf) {
  dispatcher = d;
  log = l;
  sshScope = s;
  schemaFactory = sf;

  int threads = cfg.getInt("sshd", "commandStartThreads", 2);
  startExecutor = workQueue.createQueue(threads, "SshCommandStart");
  destroyExecutor =
      Executors.newSingleThreadExecutor(
          new ThreadFactoryBuilder()
              .setNameFormat("SshCommandDestroy-%s")
              .setDaemon(true)
              .build());
}
 

import com.google.gwtorm.server.SchemaFactory; //导入依赖的package包/类
@Inject
BecomeAnyAccountLoginServlet(
    DynamicItem<WebSession> ws,
    SchemaFactory<ReviewDb> sf,
    Accounts a,
    AccountCache ac,
    AccountManager am,
    SiteHeaderFooter shf,
    Provider<InternalAccountQuery> qp) {
  webSession = ws;
  schema = sf;
  accounts = a;
  accountCache = ac;
  accountManager = am;
  headers = shf;
  queryProvider = qp;
}
 

import com.google.gwtorm.server.SchemaFactory; //导入依赖的package包/类
@Inject
EmailMerge(
    @SendEmailExecutor ExecutorService executor,
    MergedSender.Factory mergedSenderFactory,
    SchemaFactory<ReviewDb> schemaFactory,
    ThreadLocalRequestContext requestContext,
    IdentifiedUser.GenericFactory identifiedUserFactory,
    @Assisted Project.NameKey project,
    @Assisted Change.Id changeId,
    @Assisted @Nullable Account.Id submitter,
    @Assisted NotifyHandling notifyHandling,
    @Assisted ListMultimap<RecipientType, Account.Id> accountsToNotify) {
  this.sendEmailsExecutor = executor;
  this.mergedSenderFactory = mergedSenderFactory;
  this.schemaFactory = schemaFactory;
  this.requestContext = requestContext;
  this.identifiedUserFactory = identifiedUserFactory;
  this.project = project;
  this.changeId = changeId;
  this.submitter = submitter;
  this.notifyHandling = notifyHandling;
  this.accountsToNotify = accountsToNotify;
}
 

import com.google.gwtorm.server.SchemaFactory; //导入依赖的package包/类
@AssistedInject
ChangeIndexer(
    @GerritServerConfig Config cfg,
    SchemaFactory<ReviewDb> schemaFactory,
    NotesMigration notesMigration,
    ChangeNotes.Factory changeNotesFactory,
    ChangeData.Factory changeDataFactory,
    ThreadLocalRequestContext context,
    DynamicSet<ChangeIndexedListener> indexedListeners,
    StalenessChecker stalenessChecker,
    @IndexExecutor(BATCH) ListeningExecutorService batchExecutor,
    @Assisted ListeningExecutorService executor,
    @Assisted ChangeIndex index) {
  this.executor = executor;
  this.schemaFactory = schemaFactory;
  this.notesMigration = notesMigration;
  this.changeNotesFactory = changeNotesFactory;
  this.changeDataFactory = changeDataFactory;
  this.context = context;
  this.indexedListeners = indexedListeners;
  this.stalenessChecker = stalenessChecker;
  this.batchExecutor = batchExecutor;
  this.autoReindexIfStale = autoReindexIfStale(cfg);
  this.index = index;
  this.indexes = null;
}
 

import com.google.gwtorm.server.SchemaFactory; //导入依赖的package包/类
@Inject
AllChangesIndexer(
    SchemaFactory<ReviewDb> schemaFactory,
    ChangeData.Factory changeDataFactory,
    GitRepositoryManager repoManager,
    @IndexExecutor(BATCH) ListeningExecutorService executor,
    ChangeIndexer.Factory indexerFactory,
    ChangeNotes.Factory notesFactory,
    ProjectCache projectCache) {
  this.schemaFactory = schemaFactory;
  this.changeDataFactory = changeDataFactory;
  this.repoManager = repoManager;
  this.executor = executor;
  this.indexerFactory = indexerFactory;
  this.notesFactory = notesFactory;
  this.projectCache = projectCache;
}
 

import com.google.gwtorm.server.SchemaFactory; //导入依赖的package包/类
@Inject
EventFactory(
    AccountCache accountCache,
    Emails emails,
    @CanonicalWebUrl @Nullable Provider<String> urlProvider,
    PatchListCache patchListCache,
    @GerritPersonIdent PersonIdent myIdent,
    ChangeData.Factory changeDataFactory,
    ApprovalsUtil approvalsUtil,
    ChangeKindCache changeKindCache,
    Provider<InternalChangeQuery> queryProvider,
    SchemaFactory<ReviewDb> schema) {
  this.accountCache = accountCache;
  this.emails = emails;
  this.urlProvider = urlProvider;
  this.patchListCache = patchListCache;
  this.myIdent = myIdent;
  this.changeDataFactory = changeDataFactory;
  this.approvalsUtil = approvalsUtil;
  this.changeKindCache = changeKindCache;
  this.queryProvider = queryProvider;
  this.schema = schema;
}
 

import com.google.gwtorm.server.SchemaFactory; //导入依赖的package包/类
@Inject
ChangeUpdatedListener(final SmartReviewers.Factory smartReviewersFactory,
    final GitRepositoryManager repoManager, final WorkQueue workQueue,
    final IdentifiedUser.GenericFactory identifiedUserFactory,
    final ThreadLocalRequestContext tl,
    final SchemaFactory<ReviewDb> schemaFactory,
    final PluginConfigFactory cfg,
    final @PluginName String pluginName) {
  this.smartReviewersFactory = smartReviewersFactory;
  this.repoManager = repoManager;
  this.workQueue = workQueue;
  this.identifiedUserFactory = identifiedUserFactory;
  this.tl = tl;
  this.schemaFactory = schemaFactory;
  this.cfg = cfg;
  this.pluginName = pluginName;
}
 

import com.google.gwtorm.server.SchemaFactory; //导入依赖的package包/类
@Inject
public UserEventWorker(
    ChangeHooks hooks,
    WorkQueue workQueue,
    AccountResolver accountResolver,
    IdentifiedUser.GenericFactory userFactory,
    ThreadLocalRequestContext threadLocalRequestContext,
    PluginUser pluginUser,
    SchemaFactory<ReviewDb> schemaFactory) {
  this.hooks = hooks;
  this.workQueue = workQueue;
  this.accountResolver = accountResolver;
  this.userFactory = userFactory;
  this.threadLocalRequestContext = threadLocalRequestContext;
  this.pluginUser = pluginUser;
  this.schemaFactory = schemaFactory;
}
 

import com.google.gwtorm.server.SchemaFactory; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
  dispatcherMock = createMock(EventDispatcher.class);
  replay(dispatcherMock);
  ReviewDb reviewDbMock = createNiceMock(ReviewDb.class);
  replay(reviewDbMock);
  SchemaFactory<ReviewDb> schemaMock = createMock(SchemaFactory.class);
  expect(schemaMock.open()).andReturn(reviewDbMock).anyTimes();
  replay(schemaMock);
  gitUpdateProcessing = new GitUpdateProcessing(dispatcherMock);
}
 

import com.google.gwtorm.server.SchemaFactory; //导入依赖的package包/类
@Inject
CiQueryShell(SchemaFactory<CiDb> dbFactory,
    @Assisted InputStream in,
    @Assisted OutputStream out) {
  this.dbFactory = dbFactory;
  this.in = new BufferedReader(new InputStreamReader(in, UTF_8));
  this.out = new PrintWriter(new OutputStreamWriter(out, UTF_8));
}
 

import com.google.gwtorm.server.SchemaFactory; //导入依赖的package包/类
@Override
public void postRun() throws Exception {
  Injector i = buildInjector(parent);
  updater = i.getProvider(SchemaVersion.class);
  this.dbFactory = i.getInstance(
      Key.get(
          new TypeLiteral<SchemaFactory<CiDb>>() {}));
  upgradeSchema();
}
 

import com.google.gwtorm.server.SchemaFactory; //导入依赖的package包/类
@Override
protected void configure() {
  bind(new TypeLiteral<SchemaFactory<CiDb>>() {}).to(
      new TypeLiteral<Database<CiDb>>() {}).in(SINGLETON);
  bind(new TypeLiteral<Database<CiDb>>() {}).toProvider(
      CiDbDatabaseProvider.class).in(SINGLETON);
}
 

import com.google.gwtorm.server.SchemaFactory; //导入依赖的package包/类
@Inject
SiteRun(
    ConsoleUI ui,
    SitePaths site,
    InitFlags flags,
    SchemaUpdater schemaUpdater,
    @ReviewDbFactory SchemaFactory<ReviewDb> schema,
    GitRepositoryManager repositoryManager) {
  this.ui = ui;
  this.site = site;
  this.flags = flags;
  this.schemaUpdater = schemaUpdater;
  this.schema = schema;
  this.repositoryManager = repositoryManager;
}
 

import com.google.gwtorm.server.SchemaFactory; //导入依赖的package包/类
@Override
protected void configure() {
  bind(Config.class).annotatedWith(GerritServerConfig.class).toInstance(cfg);

  // TODO(dborowitz): Use jimfs.
  bind(Path.class).annotatedWith(SitePath.class).toInstance(sitePath);

  bind(GitRepositoryManager.class).to(InMemoryRepositoryManager.class);
  bind(InMemoryRepositoryManager.class).in(SINGLETON);

  bind(MetricMaker.class).to(DisabledMetricMaker.class);
  bind(DataSourceType.class).to(InMemoryH2Type.class);

  install(new NotesMigration.Module());
  TypeLiteral<SchemaFactory<ReviewDb>> schemaFactory =
      new TypeLiteral<SchemaFactory<ReviewDb>>() {};
  bind(schemaFactory).to(NotesMigrationSchemaFactory.class);
  bind(Key.get(schemaFactory, ReviewDbFactory.class)).to(InMemoryDatabase.class);
  bind(InMemoryDatabase.class).in(SINGLETON);
  bind(ChangeBundleReader.class).to(GwtormChangeBundleReader.class);

  listener().to(CreateDatabase.class);

  bind(SitePaths.class);
  bind(TrackingFooters.class).toProvider(TrackingFootersProvider.class).in(SINGLETON);

  install(new SchemaModule());
  bind(SchemaVersion.class).to(SchemaVersion.C);
}
 

import com.google.gwtorm.server.SchemaFactory; //导入依赖的package包/类
private Context(SchemaFactory<ReviewDb> sf, SshSession s, CurrentUser u, long at) {
  schemaFactory = sf;
  session = s;
  user = u;
  created = started = finished = at;
  map.put(RC_KEY, cleanup);
  map.put(DB_KEY, new RequestScopedReviewDbProvider(schemaFactory, Providers.of(cleanup)));
}
 

import com.google.gwtorm.server.SchemaFactory; //导入依赖的package包/类
public Context disableDb() {
  Context old = current.get();
  SchemaFactory<ReviewDb> sf =
      new SchemaFactory<ReviewDb>() {
        @Override
        public ReviewDb open() {
          return new DisabledReviewDb();
        }
      };
  Context ctx = new Context(sf, old.session, old.user, old.created);

  current.set(ctx);
  local.setContext(ctx);
  return old;
}
 

import com.google.gwtorm.server.SchemaFactory; //导入依赖的package包/类
@Inject
SendMessage(
    Provider<MessageFactory> messageFactory, SchemaFactory<ReviewDb> sf, SshScope sshScope) {
  this.messageFactory = messageFactory;
  this.schemaFactory = sf;
  this.sshScope = sshScope;
}