import com.google.gerrit.pgm.init.api.ConsoleUI; //导入依赖的package包/类
@Inject
InitOAuth(ConsoleUI ui, Section.Factory sections, @PluginName String pluginName) {
  this.ui = ui;
  this.googleOAuthProviderSection =
      sections.get(PLUGIN_SECTION, pluginName + GoogleOAuthService.CONFIG_SUFFIX);
  this.githubOAuthProviderSection =
      sections.get(PLUGIN_SECTION, pluginName + GitHubOAuthService.CONFIG_SUFFIX);
  this.bitbucketOAuthProviderSection =
      sections.get(PLUGIN_SECTION, pluginName + BitbucketOAuthService.CONFIG_SUFFIX);
  this.casOAuthProviderSection =
      sections.get(PLUGIN_SECTION, pluginName + CasOAuthService.CONFIG_SUFFIX);
  this.facebookOAuthProviderSection =
      sections.get(PLUGIN_SECTION, pluginName + FacebookOAuthService.CONFIG_SUFFIX);
  this.gitlabOAuthProviderSection =
      sections.get(PLUGIN_SECTION, pluginName + GitLabOAuthService.CONFIG_SUFFIX);
  this.dexOAuthProviderSection =
      sections.get(PLUGIN_SECTION, pluginName + DexOAuthService.CONFIG_SUFFIX);
  this.keycloakOAuthProviderSection =
      sections.get(PLUGIN_SECTION, pluginName + KeycloakOAuthService.CONFIG_SUFFIX);
}
 

import com.google.gerrit.pgm.init.api.ConsoleUI; //导入依赖的package包/类
private Injector createSysInjector(SiteInit init) {
  if (sysInjector == null) {
    final List<Module> modules = new ArrayList<>();
    modules.add(
        new AbstractModule() {
          @Override
          protected void configure() {
            bind(ConsoleUI.class).toInstance(init.ui);
            bind(InitFlags.class).toInstance(init.flags);
          }
        });
    Injector dbInjector = createDbInjector(SINGLE_USER);
    switch (IndexModule.getIndexType(dbInjector)) {
      case LUCENE:
        modules.add(new LuceneIndexModuleOnInit());
        break;
      case ELASTICSEARCH:
        modules.add(new ElasticIndexModuleOnInit());
        break;
      default:
        throw new IllegalStateException("unsupported index.type");
    }
    sysInjector = dbInjector.createChildInjector(modules);
  }
  return sysInjector;
}
 

import com.google.gerrit.pgm.init.api.ConsoleUI; //导入依赖的package包/类
@Inject
InitAdminUser(
    InitFlags flags,
    ConsoleUI ui,
    AllUsersNameOnInitProvider allUsers,
    AccountsOnInit accounts,
    VersionedAuthorizedKeysOnInit.Factory authorizedKeysFactory,
    ExternalIdsOnInit externalIds,
    SequencesOnInit sequencesOnInit,
    GroupsOnInit groupsOnInit) {
  this.flags = flags;
  this.ui = ui;
  this.allUsers = allUsers;
  this.accounts = accounts;
  this.authorizedKeysFactory = authorizedKeysFactory;
  this.externalIds = externalIds;
  this.sequencesOnInit = sequencesOnInit;
  this.groupsOnInit = groupsOnInit;
}
 

import com.google.gerrit.pgm.init.api.ConsoleUI; //导入依赖的package包/类
private Injector getSysInjector() {
  List<Module> modules = new ArrayList<>();
  modules.add(
      new FactoryModule() {
        @Override
        protected void configure() {
          bind(Path.class).annotatedWith(SitePath.class).toInstance(getSitePath());
          bind(ConsoleUI.class).toInstance(ConsoleUI.getInstance(password != null));
          factory(Section.Factory.class);
          bind(Boolean.class).annotatedWith(InstallAllPlugins.class).toInstance(Boolean.FALSE);
          bind(new TypeLiteral<List<String>>() {})
              .annotatedWith(InstallPlugins.class)
              .toInstance(new ArrayList<String>());
          bind(String.class)
              .annotatedWith(SecureStoreClassName.class)
              .toProvider(Providers.of(getConfiguredSecureStoreClass()));
        }
      });
  modules.add(new GerritServerConfigModule());
  return Guice.createInjector(modules);
}
 

import com.google.gerrit.pgm.init.api.ConsoleUI; //导入依赖的package包/类
@Test
public void create() throws Exception {
  final SitePaths site = new SitePaths(Paths.get("."));
  final ConsoleUI ui = createStrictMock(ConsoleUI.class);
  final StaleLibraryRemover remover = createStrictMock(StaleLibraryRemover.class);

  replay(ui);

  Libraries lib =
      new Libraries(
          new Provider<LibraryDownloader>() {
            @Override
            public LibraryDownloader get() {
              return new LibraryDownloader(ui, site, remover);
            }
          },
          Collections.<String>emptyList(),
          false);

  assertNotNull(lib.mysqlDriver);

  verify(ui);
}
 

import com.google.gerrit.pgm.init.api.ConsoleUI; //导入依赖的package包/类
@Inject
InitPlugin(Section.Factory sections,
    @PluginName String pluginName,
    ConsoleUI ui,
    SitePaths site,
    Injector parent) {
  this.ui = ui;
  this.site = site;
  this.configSection = sections.get("plugin", pluginName);
  this.parent = parent;
}
 

import com.google.gerrit.pgm.init.api.ConsoleUI; //导入依赖的package包/类
@Inject
UpgradeFrom2_0_x(
    final SitePaths site,
    final InitFlags flags,
    final ConsoleUI ui,
    final Section.Factory sections) {
  this.ui = ui;
  this.sections = sections;

  this.cfg = flags.cfg;
  this.sec = flags.sec;
  this.site_path = site.site_path;
  this.etc_dir = site.etc_dir;
}
 

import com.google.gerrit.pgm.init.api.ConsoleUI; //导入依赖的package包/类
@Inject
SiteInit(
    final SitePaths site,
    final InitFlags flags,
    final ConsoleUI ui,
    final SitePathInitializer initializer) {
  this.site = site;
  this.flags = flags;
  this.ui = ui;
  this.initializer = initializer;
}
 

import com.google.gerrit.pgm.init.api.ConsoleUI; //导入依赖的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.gerrit.pgm.init.api.ConsoleUI; //导入依赖的package包/类
@Inject
LibraryDownloader(ConsoleUI ui, SitePaths site, StaleLibraryRemover remover) {
  this.ui = ui;
  this.lib_dir = site.lib_dir;
  this.remover = remover;
  this.needs = new ArrayList<>(2);
}
 

import com.google.gerrit.pgm.init.api.ConsoleUI; //导入依赖的package包/类
@Inject
InitIndex(ConsoleUI ui, Section.Factory sections, SitePaths site, InitFlags initFlags) {
  this.ui = ui;
  this.index = sections.get("index", null);
  this.gerrit = sections.get("gerrit", null);
  this.site = site;
  this.initFlags = initFlags;
}
 

import com.google.gerrit.pgm.init.api.ConsoleUI; //导入依赖的package包/类
@Inject
InitPlugins(
    final ConsoleUI ui,
    final SitePaths site,
    InitFlags initFlags,
    InitPluginStepsLoader pluginLoader,
    PluginsDistribution pluginsDistribution) {
  this.ui = ui;
  this.site = site;
  this.initFlags = initFlags;
  this.pluginLoader = pluginLoader;
  this.pluginsDistribution = pluginsDistribution;
}
 

import com.google.gerrit.pgm.init.api.ConsoleUI; //导入依赖的package包/类
@Inject
InitDatabase(
    ConsoleUI ui,
    SitePaths site,
    Libraries libraries,
    InitFlags flags,
    Section.Factory sections) {
  this.ui = ui;
  this.site = site;
  this.libraries = libraries;
  this.flags = flags; // Don't grab any flags yet; they aren't initialized until BaseInit#run.
  this.database = sections.get("database", null);
  this.idSection = sections.get(GerritServerIdProvider.SECTION, null);
  this.noteDbChanges = sections.get(SECTION_NOTE_DB, CHANGES.key());
}
 

import com.google.gerrit.pgm.init.api.ConsoleUI; //导入依赖的package包/类
@Inject
InitAuth(InitFlags flags, ConsoleUI ui, Section.Factory sections) {
  this.flags = flags;
  this.ui = ui;
  this.auth = sections.get("auth", null);
  this.ldap = sections.get("ldap", null);
  this.receive = sections.get(RECEIVE, null);
}
 

import com.google.gerrit.pgm.init.api.ConsoleUI; //导入依赖的package包/类
@Inject
public SitePathInitializer(
    final Injector injector,
    final ConsoleUI ui,
    final InitFlags flags,
    final SitePaths site,
    final Section.Factory sectionFactory,
    @Nullable final SecureStoreInitData secureStoreInitData) {
  this.ui = ui;
  this.flags = flags;
  this.site = site;
  this.sectionFactory = sectionFactory;
  this.secureStoreInitData = secureStoreInitData;
  this.steps = stepsOf(injector);
}
 

import com.google.gerrit.pgm.init.api.ConsoleUI; //导入依赖的package包/类
@Inject
InitSshd(ConsoleUI ui, SitePaths site, Section.Factory sections, StaleLibraryRemover remover) {
  this.ui = ui;
  this.site = site;
  this.sshd = sections.get("sshd", null);
  this.remover = remover;
}
 

import com.google.gerrit.pgm.init.api.ConsoleUI; //导入依赖的package包/类
@Inject
InitCache(
    final ConsoleUI ui,
    final InitFlags flags,
    final SitePaths site,
    final Section.Factory sections) {
  this.ui = ui;
  this.flags = flags;
  this.site = site;
  this.cache = sections.get("cache", null);
}
 

import com.google.gerrit.pgm.init.api.ConsoleUI; //导入依赖的package包/类
@Inject
InitHttpd(
    final ConsoleUI ui,
    final SitePaths site,
    final InitFlags flags,
    final Section.Factory sections) {
  this.ui = ui;
  this.site = site;
  this.flags = flags;
  this.httpd = sections.get("httpd", null);
  this.gerrit = sections.get("gerrit", null);
}
 

import com.google.gerrit.pgm.init.api.ConsoleUI; //导入依赖的package包/类
@Override
protected boolean beforeInit(SiteInit init) throws Exception {
  ErrorLogFile.errorOnlyConsole();

  if (!skipPlugins) {
    final List<PluginData> plugins =
        InitPlugins.listPluginsAndRemoveTempFiles(init.site, pluginsDistribution);
    ConsoleUI ui = ConsoleUI.getInstance(false);
    if (installAllPlugins && !nullOrEmpty(installPlugins)) {
      ui.message("Cannot use --install-plugin together with --install-all-plugins.\n");
      return true;
    }
    verifyInstallPluginList(ui, plugins);
    if (listPlugins) {
      if (!plugins.isEmpty()) {
        ui.message("Available plugins:\n");
        for (PluginData plugin : plugins) {
          ui.message(" * %s version %s\n", plugin.name, plugin.version);
        }
      } else {
        ui.message("No plugins found.\n");
      }
      return true;
    }
  }
  return false;
}
 

import com.google.gerrit.pgm.init.api.ConsoleUI; //导入依赖的package包/类
private void verifyInstallPluginList(ConsoleUI ui, List<PluginData> plugins) {
  if (nullOrEmpty(installPlugins) || nullOrEmpty(plugins)) {
    return;
  }
  Set<String> missing = Sets.newHashSet(installPlugins);
  plugins.stream().forEach(p -> missing.remove(p.name));
  if (!missing.isEmpty()) {
    ui.message("Cannot find plugin(s): %s\n", Joiner.on(", ").join(missing));
    listPlugins = true;
  }
}