jetbrains.buildServer.util.EventDispatcher Java Examples

public KubePodNameGeneratorImpl(@NotNull ServerPaths serverPaths,
                            @NotNull ExecutorServices executorServices,
                            @NotNull EventDispatcher<BuildServerListener> eventDispatcher
                            ){
  myIdxStorage = new File(serverPaths.getPluginDataDirectory(), "kubeIdx");
  if (!myIdxStorage.exists()){
    myIdxStorage.mkdirs();
  }
  if (!myIdxStorage.isDirectory()){
    throw new CloudException("Unable to create a directory for kube plugin VM indexes");
  }
  myIsAvailable = new AtomicBoolean(true);

  loadIdxes(myIdxStorage);

  eventDispatcher.addListener(new BuildServerAdapter(){
    @Override
    public void serverShutdown() {
      myIsAvailable.set(false);
      storeIdxes();
    }
  });
  executorServices.getNormalExecutorService().scheduleWithFixedDelay(this::storeIdxes, 60, 60, TimeUnit.SECONDS);
}
 

@BeforeMethod
public void setUp() throws Exception {
  super.setUp();
  myServerSettings = new ServerSettingsImpl(){
    @Nullable
    @Override
    public String getServerUUID() {
      return "SERVER-UUID";
    }
  };
  final TempFiles tempFiles = new TempFiles();
  myServerPaths = new ServerPaths(tempFiles.createTempDir());
  myExecutorServices = new SimpleExecutorServices();
  myEventDispatcher = EventDispatcher.create(BuildServerListener.class);
  myNameGenerator = new KubePodNameGeneratorImpl(myServerPaths, myExecutorServices, myEventDispatcher);
  myContainerProvider = new SimpleRunContainerProvider(myServerSettings);
  myPodTemplateProviders = new BuildAgentPodTemplateProvidersImpl(myServerSettings, (name, kubeClientParams) -> null);

}
 

@BeforeMethod
@Override
protected void setUp() throws Exception {
    super.setUp();
    m = new Mockery();
    ServerSettings serverSettings = m.mock(ServerSettings.class);
    KubeAuthStrategyProvider authStrategies = m.mock(KubeAuthStrategyProvider.class);
    myDeploymentContentProvider = m.mock(DeploymentContentProvider.class);
    final ExecutorServices executorServices = m.mock(ExecutorServices.class);
    m.checking(new Expectations(){{
        allowing(serverSettings).getServerUUID(); will(returnValue("server uuid"));
        allowing(authStrategies).get(with(UnauthorizedAccessStrategy.ID)); will(returnValue(myAuthStrategy));
        ScheduledExecutorService ses = new ScheduledThreadPoolExecutor(1);
        allowing(executorServices).getNormalExecutorService(); will(returnValue(ses));
    }});
    TempFiles tempFiles = new TempFiles();
    final ServerPaths serverPaths = new ServerPaths(tempFiles.createTempDir());
    final EventDispatcher<BuildServerListener> eventDispatcher = EventDispatcher.create(BuildServerListener.class);
    myNameGenerator = new KubePodNameGeneratorImpl(serverPaths, executorServices, eventDispatcher);
    myPodTemplateProvider = new DeploymentBuildAgentPodTemplateProvider(serverSettings, myDeploymentContentProvider);
}
 

public SQMSBuildFinishServiceFactory(@NotNull final SQMSBuildFinishRunner sqmsBuildStartRunner,
                                     @NotNull final OSType osType,
                                     @NotNull final MonoLocator monoLocator,
                                     @NotNull final EventDispatcher<AgentLifeCycleListener> dispatcher, @NotNull final CurrentBuildTracker currentBuildTracker) {
    mySQMSBuildFinishRunner = sqmsBuildStartRunner;
    myOSType = osType;
    myMonoLocator = monoLocator;
    myCurrentBuildTracker = currentBuildTracker;
    dispatcher.addListener(new AgentLifeCycleAdapter() {
        @Override
        public void buildStarted(@NotNull final AgentRunningBuild runningBuild) {
            myMSBuildScannerLocator = null;
            myWorkingDirectory = null;
            mySqrParametersAccessor = null;
        }

        @Override
        public void runnerFinished(@NotNull final BuildRunnerContext runner, @NotNull final BuildFinishedStatus status) {
            if (runner.getRunType().equals(mySQMSBuildFinishRunner.getType())) {
                myMSBuildScannerLocator = null;
                myWorkingDirectory = null;
                mySqrParametersAccessor = null;
            }
        }
    });
}
 

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();
      }
    });
  }
 

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);
            }
        });
    }
}
 

public S3ArtifactsPublisher(@NotNull final AgentArtifactHelper helper,
                            @NotNull final EventDispatcher<AgentLifeCycleListener> dispatcher,
                            @NotNull final CurrentBuildTracker tracker,
                            @NotNull final BuildAgentConfiguration buildAgentConfiguration) {
  myHelper = helper;
  myTracker = tracker;
  myBuildAgentConfiguration = buildAgentConfiguration;
  dispatcher.addListener(new AgentLifeCycleAdapter() {
    @Override
    public void buildStarted(@NotNull final AgentRunningBuild runningBuild) {
      myFileUploader = null;
      myArtifacts.clear();
    }
  });
}
 

public Agent(
        @NotNull final EventDispatcher<AgentLifeCycleListener> eventDispatcher,
        @NotNull final PhabLogger phabLogger,
        @NotNull final AppConfig appConfig
){
    eventDispatcher.addListener(this);
    this.logger = phabLogger;
    this.appConfig = appConfig;
    this.logger.info("Instantiated");
}
 

public Server(
        @NotNull final EventDispatcher<BuildServerListener> buildServerListener,
        @NotNull final PhabLogger logger
){
    buildServerListener.addListener(this);
    this.logger = logger;
    Loggers.SERVER.info("Phab Server Initialized");
}
 

public SQMSBuildStartServiceFactory(@NotNull final SQMSBuildStartRunner sqmsBuildStartRunner,
                                    @NotNull final OSType osType,
                                    @NotNull final MonoLocator monoLocator,
                                    @NotNull final SQMSBuildFinishServiceFactory sqmsBuildFinishServiceFactory,
                                    @NotNull final EventDispatcher<AgentLifeCycleListener> dispatcher) {
    mySQMSBuildStartRunner = sqmsBuildStartRunner;
    myOSType = osType;
    myMonoLocator = monoLocator;
    mySqmsBuildFinishServiceFactory = sqmsBuildFinishServiceFactory;
    mySonarQubeMSBuildScannerLocator = new SonarQubeMSBuildScannerLocatorImpl();

    dispatcher.addListener(new AgentLifeCycleAdapter() {
        @Override
        public void beforeRunnerStart(@NotNull final BuildRunnerContext runner) {
            if (runner.getRunType().equals(mySQMSBuildStartRunner.getType())) {

                mySqmsBuildFinishServiceFactory.setUpFinishStep(new SonarQubeMSBuildScannerLocator() {
                    @Nullable
                    @Override
                    public String getExecutablePath(@NotNull final BuildRunnerContext runnerContext) throws RunBuildException {
                        return mySonarQubeMSBuildScannerLocator.getExecutablePath(runner);
                    }
                }, runner.getWorkingDirectory(), new SQRParametersAccessor(SQRParametersUtil.mergeAuthParameters(runner.getBuild().getSharedConfigParameters(), runner.getRunnerParameters())));
            }
        }
    });
}
 

public KubeAgentConfigurationProvider(@NotNull EventDispatcher<AgentLifeCycleListener> agentEvents,
                                      @NotNull final BuildAgentConfigurationEx agentConfigurationEx) {
    LOG.info("Initializing Kube Provider...");
    agentEvents.addListener(new AgentLifeCycleAdapter(){
        @Override
        public void afterAgentConfigurationLoaded(@NotNull BuildAgent agent) {
            super.afterAgentConfigurationLoaded(agent);
            final Map<String, String> env = System.getenv();
            final String providedServerUrl = env.get(KubeContainerEnvironment.SERVER_URL);
            if(StringUtil.isNotEmpty(providedServerUrl)) {
                LOG.info("Provided TeamCity Server URL: " + providedServerUrl);
                agentConfigurationEx.setServerUrl(providedServerUrl);
            } else {
                LOG.info("TeamCity Server URL was not provided. The instance wasn't started using TeamCity Kube integration.");
                return;
            }

            final String profileId = env.get(KubeContainerEnvironment.PROFILE_ID);
            if(StringUtil.isNotEmpty(profileId)){
                LOG.info("Provided Profile Id: " + profileId);
                agentConfigurationEx.addConfigurationParameter(KubeContainerEnvironment.REQUIRED_PROFILE_ID_CONFIG_PARAM, profileId);
            } else {
                LOG.info("Profile Id was not provided. The instance wasn't started using TeamCity Kube integration.");
                return;
            }

            final String instanceName = env.get(KubeContainerEnvironment.INSTANCE_NAME);
            if (StringUtil.isNotEmpty(instanceName)) {
                LOG.info("Setting instance name to " + instanceName);
                agentConfigurationEx.setName(instanceName);
            } else {
                LOG.warn("Couldn't find 'env." + KubeContainerEnvironment.INSTANCE_NAME + "' property" );
            }

            for (Map.Entry<String, String> entry : env.entrySet()){
                final String key = entry.getKey();
                final String value = entry.getValue();
                if (key.startsWith(TEAMCITY_KUBERNETES_PROVIDED_PREFIX)){
                    LOG.info("prop( " + key + ") : " + value);
                    agentConfigurationEx.addConfigurationParameter(key.substring(TEAMCITY_KUBERNETES_PROVIDED_PREFIX.length()), value);
                }
            }
        }
    });
}
 

public WinDbgToolsDetector(@NotNull final EventDispatcher<AgentLifeCycleListener> events,
                           @NotNull final Win32RegistryAccessor registryAccessor) {
  myRegistryAccessor = registryAccessor;
  events.addListener(this);
}
 

public AnsibleReportArtifatcsProvider(
        @NotNull ArtifactsWatcher artifactsWatcher,
        @NotNull EventDispatcher<AgentLifeCycleListener> agentDispatcher) {
    agentDispatcher.addListener(this);
    this.artifactsWatcher = artifactsWatcher;
}
 

public BuildBreakerProblemListener(@NotNull final EventDispatcher<AgentLifeCycleListener> agentDispatcher) {
    agentDispatcher.addListener(this);
}
 

public SonarProcessListener(@NotNull final EventDispatcher<AgentLifeCycleListener> agentDispatcher,
                            @NotNull final ArtifactsWatcher watcher) {
    myWatcher = watcher;
    agentDispatcher.addListener(this);
}
 

public VMWarePropertiesReader(final BuildAgentConfigurationEx agentConfiguration,
                              @NotNull EventDispatcher<AgentLifeCycleListener> events) {
  LOG.info("VSphere plugin initializing...");
  myAgentConfiguration = agentConfiguration;
  myVMWareRPCToolPath = getToolPath(myAgentConfiguration);
  if (myVMWareRPCToolPath == null) {
    LOG.info("Unable to locate " + VMWARE_RPCTOOL_NAME + ". Looks like not a VMWare VM or VWWare tools are not installed");
    return;
  } else {
    LOG.info("Detected vmware-tools or open-vm-tools. Found required vmware-rpctool at " + myVMWareRPCToolPath + ". " +
        "Will attempt to authorize agent as VMWare cloud agent. ");
  }
  events.addListener(new AgentLifeCycleAdapter(){
    @Override
    public void afterAgentConfigurationLoaded(@NotNull final BuildAgent agent) {
      final String serverUrl = getPropertyValue(SERVER_URL);
      if (StringUtil.isEmpty(serverUrl)){
        LOG.info("Unable to read property " + SERVER_URL + ". VMWare integration is disabled");
        return;
      } else {
        LOG.info("Server URL: " + serverUrl);
      }
      final String instanceName = getPropertyValue(INSTANCE_NAME);
      if (StringUtil.isEmpty(instanceName)){
        LOG.info("Unable to read property " + INSTANCE_NAME + ". VMWare integration is disabled");
        return;
      } else {
        LOG.info("Instance name: " + instanceName);
      }

      myAgentConfiguration.setName(instanceName);
      myAgentConfiguration.setServerUrl(serverUrl);
      myAgentConfiguration.addConfigurationParameter(INSTANCE_NAME, instanceName);

      String imageName = getPropertyValue(IMAGE_NAME);
      if (!StringUtil.isEmpty(imageName)){
        LOG.info("Image name: " + imageName);
        myAgentConfiguration.addConfigurationParameter(IMAGE_NAME, imageName);
      }

      String userData = getPropertyValue(USER_DATA);
      if (!StringUtil.isEmpty(userData)){
        LOG.debug("UserData: " + userData);
        final CloudInstanceUserData cloudUserData = CloudInstanceUserData.deserialize(userData);
        if (cloudUserData != null) {
          final Map<String, String> customParameters = cloudUserData.getCustomAgentConfigurationParameters();
          for (Map.Entry<String, String> entry : customParameters.entrySet()) {
            myAgentConfiguration.addConfigurationParameter(entry.getKey(), entry.getValue());
          }
        }
      }
    }
  });
}