Java InitMilestone类代码示例

import hudson.init.InitMilestone; //导入依赖的package包/类
@Initializer(before = InitMilestone.COMPLETED, after = InitMilestone.JOB_LOADED)
public static void jobLoaded() throws IOException
{
	m_logger.fine("Initialization milestone: All jobs have been loaded"); //$NON-NLS-1$
	Jenkins jenkins = Jenkins.getInstance();
	for (AbstractProject<?, ?> project : jenkins.getAllItems(AbstractProject.class))
	{
		try
		{
			SCM scmConfig = project.getScm();
			if (scmConfig instanceof AbstractConfiguration && ((AbstractConfiguration) scmConfig).isMigrated())
			{
				project.save();

				m_logger.info(String.format(
								"Project %s has been migrated.", //$NON-NLS-1$
								project.getFullName()));
			}
		}
		catch (IOException e)
		{
			m_logger.log(Level.SEVERE, String.format("Failed to upgrade job %s", project.getFullName()), e); //$NON-NLS-1$
		}
	}
}
 

import hudson.init.InitMilestone; //导入依赖的package包/类
public void run() {
    // TODO switch to Jenkins.getActiveInstance() once 1.590+ is the baseline
    Jenkins jenkins = Jenkins.getInstance();
    if (jenkins == null) {
        throw new IllegalStateException("Jenkins has not been started, or was already shut down");
    }
    while (jenkins.getInitLevel() != InitMilestone.COMPLETED) {
        try {
            logger.log(Level.INFO, "Waiting for Jenkins to be up before computing disk usage");
            Thread.sleep(3 * 60 * 1000);
        } catch (InterruptedException e) {
            return;
        }
    }
    refreshData();
}
 

import hudson.init.InitMilestone; //导入依赖的package包/类
@Initializer(before = InitMilestone.JOB_LOADED)
@Restricted(NoExternalUse.class)
public static void packageRenameConverting() {
    for(XStream2 xs : Arrays.asList(Items.XSTREAM2, Run.XSTREAM2, Jenkins.XSTREAM2, getFingerprintXStream())) {
        xs.addCompatibilityAlias("org.jenkinsci.plugins.dockerhub.notification.DockerHubTrigger",
                                 DockerHubTrigger.class);
        xs.addCompatibilityAlias("org.jenkinsci.plugins.dockerhub.notification.DockerHubWebHookCause",
                                 DockerHubWebHookCause.class);
        xs.addCompatibilityAlias("org.jenkinsci.plugins.dockerhub.notification.DockerPullImageBuilder",
                                 DockerPullImageBuilder.class);
        //TODO no back-compat tests for the column and filter
        xs.addCompatibilityAlias("org.jenkinsci.plugins.dockerhub.notification.TriggerListViewColumn",
                                 TriggerListViewColumn.class);
        xs.addCompatibilityAlias("org.jenkinsci.plugins.dockerhub.notification.TriggerViewFilter",
                                 TriggerViewFilter.class);
        //The TriggerOption extension point has also changed package name and will not be backwards compatible API
        xs.addCompatibilityAlias("org.jenkinsci.plugins.dockerhub.notification.opt.impl.TriggerForAllUsedInJob",
                                 TriggerForAllUsedInJob.class);
        xs.addCompatibilityAlias("org.jenkinsci.plugins.dockerhub.notification.opt.impl.TriggerOnSpecifiedImageNames",
                                 TriggerOnSpecifiedImageNames.class);
        xs.addCompatibilityAlias("org.jenkinsci.plugins.dockerhub.notification.TriggerStore$TriggerEntry",
                                 TriggerStore.TriggerEntry.class);
        xs.addCompatibilityAlias("org.jenkinsci.plugins.dockerhub.notification.TriggerStore$TriggerEntry$RunEntry",
                                 TriggerStore.TriggerEntry.RunEntry.class);
    }
}
 

import hudson.init.InitMilestone; //导入依赖的package包/类
/**
 * Gets the effective singleton instance.
 *
 * @return the effective singleton instance.
 * @throws AssertionError if the singleton is missing, i.e. not running on a Jenkins master.
 */
@Nonnull
public static TriggerStore getInstance() {
    Jenkins instance = Jenkins.getInstance();
    TriggerStore d;
    if (instance == null) {
        d = null;
    } else if (instance.getInitLevel().compareTo(InitMilestone.JOB_LOADED) < 0) {
        throw new AssertionError(TriggerStore.class.getName() + " is not available until after all jobs are loaded");
    } else {
        d = instance.getDescriptorByType(TriggerStore.class);
    }
    if (d == null) {
        throw new AssertionError(TriggerStore.class.getName() + " is missing");
    }
    return d;
}
 

import hudson.init.InitMilestone; //导入依赖的package包/类
/**
 * Creates a default tool installation if needed. Uses "ninja" or migrates
 * data from previous versions
 *
 */
@Initializer(after = InitMilestone.EXTENSIONS_AUGMENTED)
public static void onLoaded() {

    Jenkins jenkinsInstance = Jenkins.getInstance();
    if (jenkinsInstance == null) {
        return;
    }
    DescriptorImpl descriptor = (DescriptorImpl) jenkinsInstance
            .getDescriptor(NinjaTool.class);
    NinjaTool[] installations = getInstallations(descriptor);

    if (installations != null && installations.length > 0) {
        // No need to initialize if there's already something
        return;
    }

    NinjaTool tool = new NinjaTool(DEFAULT, "ninja",
            Collections.<ToolProperty<?>> emptyList());
    descriptor.setInstallations(new NinjaTool[] { tool });
    descriptor.save();
}
 

import hudson.init.InitMilestone; //导入依赖的package包/类
@Initializer(after=InitMilestone.PLUGINS_STARTED)
public static void init() {
    if (germanHolidayCalculator == null) {
        germanHolidayCalculator = new GermanHolidayCalculator();
    }

    Calendar now = Calendar.getInstance();

    int year = now.get(Calendar.YEAR);

    for (int i = 0; i < 6; i++) {
        year = year + i;
        List<Calendar> holidays = germanHolidayCalculator.calculatePublicHolidays(year);
        publicHolidays.put(year, holidays);
    }
}
 

import hudson.init.InitMilestone; //导入依赖的package包/类
@Initializer(before = InitMilestone.PLUGINS_STARTED)
public static void addAliases() {
    Jenkins.XSTREAM2.addCompatibilityAlias(
            "org.csanchez.jenkins.plugins.kubernetes.OpenShiftBearerTokenCredentialImpl",
            org.jenkinsci.plugins.kubernetes.credentials.OpenShiftBearerTokenCredentialImpl.class);
    Jenkins.XSTREAM2.addCompatibilityAlias(
            "org.csanchez.jenkins.plugins.kubernetes.OpenShiftTokenCredentialImpl",
            StringCredentialsImpl.class);
    Jenkins.XSTREAM2.addCompatibilityAlias("org.csanchez.jenkins.plugins.kubernetes.ServiceAccountCredential",
            org.jenkinsci.plugins.kubernetes.credentials.FileSystemServiceAccountCredential.class);
}
 

import hudson.init.InitMilestone; //导入依赖的package包/类
@Initializer(after = InitMilestone.PLUGINS_STARTED)
public static void migrate() throws IOException {
    GitLabConnectionConfig descriptor = (GitLabConnectionConfig) Jenkins.getInstance().getDescriptor(GitLabConnectionConfig.class);
    for (GitLabConnection connection : descriptor.getConnections()) {
        if (connection.apiTokenId == null && connection.apiToken != null) {
            for (CredentialsStore credentialsStore : CredentialsProvider.lookupStores(Jenkins.getInstance())) {
                if (credentialsStore instanceof SystemCredentialsProvider.StoreImpl) {
                    List<Domain> domains = credentialsStore.getDomains();
                    connection.apiTokenId = UUID.randomUUID().toString();
                    credentialsStore.addCredentials(domains.get(0),
                        new GitLabApiTokenImpl(CredentialsScope.SYSTEM, connection.apiTokenId, "GitLab API Token", Secret.fromString(connection.apiToken)));
                }
            }
        }
    }
    descriptor.save();
}
 

import hudson.init.InitMilestone; //导入依赖的package包/类
@Initializer(after = InitMilestone.JOB_LOADED)
public static void initialize() {
    new Thread(new Runnable() {
        @Override
        public void run() {
            ACL.impersonate(ACL.SYSTEM, new ListenerInitializerTask(GitLabSCMWebHook.get()));
        }
    }).start();
}
 

import hudson.init.InitMilestone; //导入依赖的package包/类
@Initializer(after = InitMilestone.PLUGINS_STARTED)
public static void initAliases() {
    Jenkins jenkins = Jenkins.getInstance();
    if (jenkins == null) {
        LOGGER.severe("Called for initialization but Jenkins instance no longer available.");
        return;
    }
    // Alias all RunSelectors to their simple names
    for (Descriptor<RunSelector> d : jenkins.getDescriptorByType(DescriptorImpl.class).getRunSelectors())
        XSTREAM.alias(d.clazz.getSimpleName(), d.clazz);
}
 

import hudson.init.InitMilestone; //导入依赖的package包/类
/**
 * 
 */
@Initializer(after=InitMilestone.PLUGINS_STARTED)
public static void initAliases() {
    Jenkins jenkins = Jenkins.getInstance();
    if (jenkins == null) {
        LOGGER.severe("Called for initialization but Jenkins instance no longer available.");
        return;
    }
    for (RunFilterDescriptor d : RunFilter.all()) {
        XSTREAM.alias(d.clazz.getSimpleName(), d.clazz);
    }
}
 

import hudson.init.InitMilestone; //导入依赖的package包/类
/**
 * Let's trigger an update after Jenkins is fully up.
 *
 * JOB_LOADED is the last milestone that can be triggered with an @Initializer,
 * COMPLETED doesn't work. So, we queue the update and check that Jenkins is fully up in the runnable
 * used in refreshDataOnStartup()
 */
@Initializer(after = InitMilestone.JOB_LOADED)
public static void initialize() {
    // TODO switch to Jenkins.getActiveInstance() once 1.590+ is the baseline
    Jenkins jenkins = Jenkins.getInstance();
    if (jenkins == null) {
        throw new IllegalStateException("Jenkins has not been started, or was already shut down");
    }
    QuickDiskUsagePlugin plugin = jenkins.getPlugin(QuickDiskUsagePlugin.class);
    if (plugin == null) return;
    plugin.refreshDataOnStartup();
}
 

import hudson.init.InitMilestone; //导入依赖的package包/类
@Initializer(before=InitMilestone.PLUGINS_STARTED)
public static void initializeXStream() {
	InheritableParameterReferenceConverter conv = new InheritableParameterReferenceConverter();
	
	final XStream2[] xs = {
			Jenkins.XSTREAM2, Run.XSTREAM2, Items.XSTREAM2
	};
	for (XStream2 x : xs) {
		//Add the custom converter to hide some fields
		x.registerConverter(conv);
	}
}
 

import hudson.init.InitMilestone; //导入依赖的package包/类
/**
 * We want to start the Mesos scheduler as part of the initialization of Jenkins
 * and after the cloud class values have been restored from persistence.If this is
 * the very first time, this method will be NOOP as MesosCloud is not registered yet.
 */

@Initializer(after=InitMilestone.JOB_LOADED)
public static void init() {

  Jenkins jenkins = getJenkins();
  List<Node> slaves = jenkins.getNodes();

  // Turning the AUTOMATIC_SLAVE_LAUNCH flag off because the below slave removals
  // causes computer launch in other slaves that have not been removed yet.
  // To study how a slave removal updates the entire list, one can refer to
  // Hudson NodeProvisioner class and follow this method chain removeNode() ->
  // setNodes() -> updateComputerList() -> updateComputer().
  Jenkins.AUTOMATIC_SLAVE_LAUNCH = false;
  for (Node n : slaves) {
    //Remove all slaves that were persisted when Jenkins shutdown.
    if (n instanceof MesosSlave) {
      ((MesosSlave)n).terminate();
    }
  }

  // Turn it back on for future real slaves.
  Jenkins.AUTOMATIC_SLAVE_LAUNCH = true;

  for (Cloud c : jenkins.clouds) {
    if( c instanceof MesosCloud) {
      // Register mesos framework on init, if on demand registration is not enabled.
      if (!((MesosCloud) c).isOnDemandRegistration()) {
        ((MesosCloud)c).restartMesos();
      }
    }
  }
}
 

import hudson.init.InitMilestone; //导入依赖的package包/类
/**
 * Replaces {@link LoadBalancer} registered to Jenkins to ScoringLoadBalancer.
 * 
 * The {@link LoadBalancer} originally registered are used as one to fall back.
 */
@Initializer(after=InitMilestone.PLUGINS_STARTED, fatal=false)
public static void installLoadBalancer()
{
    LOGGER.info("Replace LoadBalancer to ScoringLoadBalancer");
    Queue q = Jenkins.getInstance().getQueue();
    LoadBalancer fallback = q.getLoadBalancer();
    q.setLoadBalancer(new ScoringLoadBalancer(fallback));
}