import jetbrains.buildServer.util.EventDispatcher; //导入依赖的package包/类
public RunAsPropertiesExtension(
  @NotNull final EventDispatcher<AgentLifeCycleListener> events,
  @NotNull final ToolProvidersRegistry toolProvidersRegistry,
  @NotNull final BuildRunnerContextProvider buildRunnerContextProvider,
  @NotNull final CommandLineExecutor commandLineExecutor,
  @NotNull final ProfileParametersService profileParametersService,
  @NotNull final FileAccessCacheManager buildFileAccessCacheManager,
  @NotNull final Environment environment) {
  myToolProvidersRegistry = toolProvidersRegistry;
  myBuildRunnerContextProvider = buildRunnerContextProvider;
  myCommandLineExecutor = commandLineExecutor;
  myProfileParametersService = profileParametersService;
  myBuildFileAccessCacheManager = buildFileAccessCacheManager;
  myEnvironment = environment;
  events.addListener(this);
}
 

import jetbrains.buildServer.util.EventDispatcher; //导入依赖的package包/类
@BeforeMethod
  @Override
  protected void setUp() throws Exception {
    super.setUp();
//    setPartialMessagesChecker();
    new TeamCityProperties() {{
      setModel(new BasePropertiesModel() {
        @NotNull
        @Override
        public Map<String, String> getUserDefinedProperties() {
          return CollectionsUtil.asMap("teamcity.agent.build.messages.translators.enabled", "true");
        }
      });
    }};
    myEventDispatcher = EventDispatcher.create(AgentLifeCycleListener.class);
    myCurrentBuildTracker = new CurrentBuildTrackerImpl(myEventDispatcher);
    myTranslatorsRegistry = new TranslatorsRegistryImpl();
    myParserLoader = new ParserLoaderImpl(myCurrentBuildTracker);
    myParsersRegistry = new ParsersRegistryImpl(myTranslatorsRegistry, myParserLoader);
  }
 

import jetbrains.buildServer.util.EventDispatcher; //导入依赖的package包/类
public UserUIDAndGIDImpl(@NotNull final EventDispatcher<AgentLifeCycleListener> events) {

    events.addListener(new AgentLifeCycleAdapter(){
      @Override
      public void afterAgentConfigurationLoaded(@NotNull final BuildAgent agent) {
        final BuildAgentConfiguration configuration = agent.getConfiguration();

        if (configuration.getConfigurationParameters().get(VMConstants.DOCKER_PROPERTY) == null) return;
        if (!configuration.getSystemInfo().isUnix()) return;
        if (configuration.getSystemInfo().isWindows()) return;
        if (configuration.getSystemInfo().isMac()) return;

        detectSidAndGid();
      }
    });
  }
 

import jetbrains.buildServer.util.EventDispatcher; //导入依赖的package包/类
public ReportsFeature(EventDispatcher<BuildServerListener> dispatcher, @NotNull ReportsDescriptor descriptor, @NotNull ReportsConstants constants) {
    this.editParametersUrl = descriptor.getFeaturePath();
    this.constants = constants;
    this.jsonFactory = JacksonFactory.getDefaultInstance();

    try {
        this.httpTransport = GoogleNetHttpTransport.newTrustedTransport();
    } catch (GeneralSecurityException | IOException e) {
        throw new RuntimeException(e);
    }

    if (dispatcher != null) {
        dispatcher.addListener(new BuildServerAdapter() {
            @Override
            public void buildFinished(SRunningBuild build) {
                handleBuildFinished(build);
            }
        });
    }
}
 

import jetbrains.buildServer.util.EventDispatcher; //导入依赖的package包/类
public AgentTorrentsManager(@NotNull final EventDispatcher<AgentLifeCycleListener> eventDispatcher,
                            @NotNull final ArtifactCacheProvider artifactsCacheProvider,
                            @NotNull final CurrentBuildTracker currentBuildTracker,
                            @NotNull final TorrentConfiguration trackerManager,
                            @NotNull final AgentTorrentsSeeder torrentsSeeder,
                            @NotNull final TorrentFilesFactoryImpl torrentFilesFactory,
                            @NotNull final ArtifactsWatcher artifactsWatcher,
                            @NotNull final TorrentsDownloadStatistic torrentsDownloadStatistic,
                            @NotNull final LeechSettings leechSettings,
                            @NotNull final BuildAgentConfiguration agentConfiguration,
                            @NotNull final SeedSettings seedingSettings) throws Exception {
  myLeechSettings = leechSettings;
  mySeedingSettings = seedingSettings;
  eventDispatcher.addListener(this);
  myTrackerManager = trackerManager;
  myTorrentsSeeder = torrentsSeeder;
  myTorrentsDownloadStatistic = torrentsDownloadStatistic;
  artifactsCacheProvider.addListener(new TorrentArtifactCacheListener(
          torrentsSeeder.getTorrentsSeeder(),
          currentBuildTracker,
          trackerManager,
          this,
          torrentFilesFactory,
          artifactsWatcher,
          agentConfiguration));
}
 

import jetbrains.buildServer.util.EventDispatcher; //导入依赖的package包/类
public AgentConfiguration(@NotNull final EventDispatcher<AgentLifeCycleListener> dispatcher,
                          @NotNull final BuildAgentConfiguration buildAgentConfiguration,
                          @NotNull CurrentBuildTracker currentBuildTracker) {
  myCurrentBuildTracker = currentBuildTracker;
  myBuildAgentConfiguration = buildAgentConfiguration;
  dispatcher.addListener(new AgentLifeCycleAdapter() {
    @Override
    public void afterAgentConfigurationLoaded(@NotNull BuildAgent agent) {
      String serverUrl = agent.getConfiguration().getServerUrl();
      if (StringUtil.isNotEmpty(serverUrl)) {
        myXmlRpcTarget = XmlRpcFactory.getInstance().create(serverUrl, "TeamCity Agent", 30000, false);
      } else {
        Loggers.AGENT.error("Cannot create RPC instance for torrent plugin: server url is not specified");
      }
    }
  });
}
 

import jetbrains.buildServer.util.EventDispatcher; //导入依赖的package包/类
@BeforeMethod
public void setUp() throws Exception {

  Mockery m = new Mockery();
  final XmlRpcHandlerManager rpcHandlerManager = m.mock(XmlRpcHandlerManager.class);
  final ExecutorServices executorServices = m.mock(ExecutorServices.class);
  myExecutorService = Executors.newScheduledThreadPool(4);
  final RootUrlHolder rootUrlHolder = m.mock(RootUrlHolder.class);
  m.checking(new Expectations() {{
    allowing(rpcHandlerManager).addHandler(with(any(String.class)), with(any(Object.class)));
    allowing(executorServices).getNormalExecutorService(); will(returnValue(myExecutorService));
    allowing(rootUrlHolder).getRootUrl(); will(returnValue("http://localhost:8111"));
  }});
  myTorrentTrackerManager = new TorrentTrackerManager(
          new TorrentConfigurator(new ServerPaths("/tmp"), rootUrlHolder, rpcHandlerManager),
          executorServices,
          new EventDispatcher<BuildServerListener>(BuildServerListener.class) {
          },
          m.mock(AddressChecker.class)
  );

}
 

import jetbrains.buildServer.util.EventDispatcher; //导入依赖的package包/类
public PowerShellInfoProvider(@NotNull final BuildAgentConfiguration config,
                              @NotNull final EventDispatcher<AgentLifeCycleListener> events,
                              @NotNull final List<PowerShellDetector> detectors) {
  myConfig = config;
  events.addListener(new AgentLifeCycleAdapter(){

    @Override
    public void afterAgentConfigurationLoaded(@NotNull BuildAgent agent) {
      registerDetectedPowerShells(detectors, new DetectionContext(agent.getConfiguration()));
    }
  });
}
 

import jetbrains.buildServer.util.EventDispatcher; //导入依赖的package包/类
@Override
@BeforeMethod
@SuppressWarnings("unchecked")
public void setUp() throws Exception {
  super.setUp();
  m = new Mockery() {{
    setImposteriser(ClassImposteriser.INSTANCE);
  }};
  myEvents = m.mock(EventDispatcher.class);
  myConfig = m.mock(BuildAgentConfiguration.class);
  m.checking(new Expectations() {{
    allowing(myEvents);
  }});
  myProvider = new PowerShellInfoProvider(myConfig, myEvents, Collections.<PowerShellDetector>emptyList());
}
 

import jetbrains.buildServer.util.EventDispatcher; //导入依赖的package包/类
public AutotoolsToolProvider(@NotNull final ToolProvidersRegistry toolProvidersRegistry,
                             @NotNull final EventDispatcher<AgentLifeCycleListener> eventDispatcher, @NotNull final String toolName, @NotNull final String versionArg){
  toolProvidersRegistry.registerToolProvider(this);
  eventDispatcher.addListener(this);
  myVersionArg = versionArg;
  myToolName = toolName;
}
 

import jetbrains.buildServer.util.EventDispatcher; //导入依赖的package包/类
public HelmAgentConfigurationProvider(@NotNull EventDispatcher<AgentLifeCycleListener> agentEvents) {
    agentEvents.addListener(new AgentLifeCycleAdapter(){
        @Override
        public void beforeAgentConfigurationLoaded(@NotNull BuildAgent agent) {
            File defaultHelmLocation = new File("/usr/local/bin/helm");
            if(defaultHelmLocation.exists()){
                agent.getConfiguration().addConfigurationParameter(HELM_PATH_CONFIG_PARAM, defaultHelmLocation.getAbsolutePath());
            }
            super.beforeAgentConfigurationLoaded(agent);
        }
    });
}
 

import jetbrains.buildServer.util.EventDispatcher; //导入依赖的package包/类
public KubeAgentConfigurationProvider(@NotNull EventDispatcher<AgentLifeCycleListener> agentEvents,
                                      @NotNull BuildAgentConfigurationEx agentConfigurationEx) {
    myAgentConfigurationEx = agentConfigurationEx;
    agentEvents.addListener(new AgentLifeCycleAdapter(){
        @Override
        public void afterAgentConfigurationLoaded(@NotNull BuildAgent agent) {
            super.afterAgentConfigurationLoaded(agent);
            appendKubeSpecificConfiguration();
        }
    });
}
 

import jetbrains.buildServer.util.EventDispatcher; //导入依赖的package包/类
public HubServerListener(@NotNull final EventDispatcher<BuildServerListener> dispatcher,
        @NotNull final SBuildServer server, @NotNull final ServerPaths serverPaths) {
    this.server = server;

    dispatcher.addListener(this);

    configPersistenceManager = new ServerHubConfigPersistenceManager(serverPaths);
}
 

import jetbrains.buildServer.util.EventDispatcher; //导入依赖的package包/类
public ContainerCloudAgentPropertiesSetter(final BuildAgentConfigurationEx agentConfiguration,
                                           @NotNull EventDispatcher<AgentLifeCycleListener> events) {
    LOG.info("Created ContainerCloudAgentPropertiesSetter");
    this.agentConfiguration = agentConfiguration;
    this.events = events;

    events.addListener(new AgentLifeCycleAdapter() {
        @Override
        public void afterAgentConfigurationLoaded(@NotNull BuildAgent buildAgent) {
            LOG.info("ContainerCloudAgentPropertiesSetter: Setting terminate after build flag");
            agentConfiguration.addConfigurationParameter(CloudConstants.AGENT_TERMINATE_AFTER_BUILD, "true");
        }
    });
}
 

import jetbrains.buildServer.util.EventDispatcher; //导入依赖的package包/类
public ServerListener(@NotNull final EventDispatcher<BuildServerListener> dispatcher,
        @NotNull final SBuildServer server, @NotNull ServerPaths serverPaths) {
    this.server = server;

    dispatcher.addListener(this);

    configPersistenceManager = new ServerConfigPersistenceManager(serverPaths);
}
 

import jetbrains.buildServer.util.EventDispatcher; //导入依赖的package包/类
public DOAgentPropsUpdater(final BuildAgentConfiguration agentConfiguration,
                           @NotNull EventDispatcher<AgentLifeCycleListener> events) {
    LOG.info("DO plugin initializing...");
    agentConfig = agentConfiguration;

    events.addListener(new AgentLifeCycleAdapter() {
        @Override
        public void afterAgentConfigurationLoaded(@NotNull final BuildAgent agent) {
            final String ipv4 = getIPv4();
            agentConfig.addConfigurationParameter(DOConfigConstants.AGENT_IPV4_PROP_KEY, ipv4);
            agentConfig.addConfigurationParameter(DOConfigConstants.IDENTITY_KEY, DOConfigConstants.IDENTITY_VALUE);
        }
    });
}
 

import jetbrains.buildServer.util.EventDispatcher; //导入依赖的package包/类
public BuildStartedListener(EventDispatcher<AgentLifeCycleListener> listener)
{
    listener.addListener(new AgentLifeCycleAdapter()
    {
        /**
         * Store the JSON-string parameters (if defined) to the corresponding JSON files.
         *
         * @param build the build whose sources are being updated
         */
        @Override
        public void sourcesUpdated(@NotNull AgentRunningBuild build) {
            Loggers.AGENT.debug("[SinCity] sourcesUpdated(" + build + ") triggered");
            super.sourcesUpdated(build);
            new ParamsToFiles(build).storeIfSet();
        }

        /**
         * Store the JSON-string parameters (if defined) to the corresponding JSON files.
         *
         * @param runner the runner that is about to start
         */
        @Override
        public void beforeRunnerStart(@NotNull BuildRunnerContext runner) {
            Loggers.AGENT.debug("[SinCity] beforeRunnerStart(" + runner.getBuild() + ", " + runner.getName() + ") triggered");
            super.beforeRunnerStart(runner);
            new ParamsToFiles(runner.getBuild()).storeIfSet();
        }
    });
}
 

import jetbrains.buildServer.util.EventDispatcher; //导入依赖的package包/类
public CacheManagerImpl(MetricRegistry metricRegistry, BuildTriggerProperties buildTriggerProperties, @NotNull EventDispatcher<BuildServerListener> eventDispatcher) {
    this.buildTriggerProperties = buildTriggerProperties;
    this.ehCacheManager = net.sf.ehcache.CacheManager.newInstance();
    eventDispatcher.addListener(new BuildServerAdapter() {
        public void serverShutdown() {
            LOG.debug("Server shutdown initiated - shutting down ehCacheManager");
            ehCacheManager.shutdown();
            cacheAlive = false;
            LOG.debug("Server shutdown initiated - ehCacheManager shutdown complete");
        }
    });
    this.cacheAlive = true;
    this.metricRegistry = metricRegistry;
    this.caches = new HashMap<>();
}
 

import jetbrains.buildServer.util.EventDispatcher; //导入依赖的package包/类
public UpdateChecker(@NotNull final PluginDescriptor pluginDescriptor,
                     CacheManager cacheManager,
                     MetricRegistry metricRegistry,
                     BuildTriggerProperties buildTriggerProperties,
                     @NotNull EventDispatcher<BuildServerListener> eventDispatcher) throws NoSuchAlgorithmException, KeyStoreException, KeyManagementException, ProjectNotFoundException, InvalidCacheConfigurationException, IOException, UnexpectedResponseCodeException, ParseException, URISyntaxException, InvalidOctopusUrlException, InvalidOctopusApiKeyException {
    this.eventDispatcher = eventDispatcher;
    HttpContentProviderFactory contentProviderFactory = new HttpContentProviderFactory(null, null,
            buildTriggerProperties, cacheManager, metricRegistry);
    HttpContentProvider contentProvider = contentProviderFactory.getContentProvider();
    this.pluginDescriptor = pluginDescriptor;
    this.httpContentProvider = contentProvider;
    this.buildTriggerProperties = buildTriggerProperties;
    setupScheduledTask();
}
 

import jetbrains.buildServer.util.EventDispatcher; //导入依赖的package包/类
public HighlighterPageExtension(@NotNull PagePlaces pagePlaces, @NotNull SBuildServer sBuildServer,
                                EventDispatcher<BuildServerListener> eventDispatcher)
{
    super(pagePlaces, BUILD_RESULTS_FRAGMENT, PLUGIN_ID, "web/highlighter.jsp");
    this.sBuildServer = sBuildServer;
    this.eventDispatcher = eventDispatcher;
}