Java Computer類代碼示例

import hudson.model.Computer; //導入依賴的package包/類
@LocalData
@Test
public void localRootPathToNodeMountPoint() throws Exception {

    // The node configuration version 1.0.0 contains a localRootPath field.
    // This tests that future versions load this field as nodeMountPoint,
    // in other words it tests NodeDisk.readResolve()

    Computer computer = jr.getInstance().getComputer("node1");
    Node node = computer.getNode();
    DescribableList<NodeProperty<?>,NodePropertyDescriptor> props = node.getNodeProperties();
    ExternalWorkspaceProperty exwsProp = props.get(ExternalWorkspaceProperty.class);

    List<NodeDiskPool> diskPools = exwsProp.getNodeDiskPools();
    assertThat(diskPools.size(), is(1));

    NodeDiskPool diskPool = diskPools.get(0);
    assertThat(diskPool.getDiskPoolRefId(), is ("dp1"));

    List<NodeDisk> disks = diskPool.getNodeDisks();
    assertThat(disks.size(), is(1));

    NodeDisk disk = disks.get(0);
    assertThat(disk.getDiskRefId(), is("d1"));
    assertThat(disk.getNodeMountPoint(), is("/tmp/dp1/d1"));
}
 

import hudson.model.Computer; //導入依賴的package包/類
@Test @Issue("JENKINS-41037")
public void modifiedWhileSerialized() throws Exception {
    final CloudStatistics cs = CloudStatistics.get();
    final CloudStatistics.ProvisioningListener l = CloudStatistics.ProvisioningListener.get();
    final ProvisioningActivity activity = l.onStarted(new ProvisioningActivity.Id("Cloud", "template", "PAOriginal"));
    final StatsModifyingAttachment blocker = new StatsModifyingAttachment(OK, "Blocker");
    Computer.threadPoolForRemoting.submit(new Callable<Object>() {
        @Override public Object call() throws Exception {
            cs.attach(activity, PROVISIONING, blocker);
            cs.persist();
            return null;
        }
    }).get();

    String serialized = cs.getConfigFile().asString();
    assertThat(serialized, not(containsString("ConcurrentModificationException")));
    assertThat(serialized, not(containsString("active class=\"linked-hash-set\"")));
    assertThat(serialized, containsString("Blocker"));
    assertThat(serialized, containsString("PAOriginal"));
    assertThat(serialized, containsString("PAModifying"));
    assertThat(serialized, containsString("active class=\"java.util.concurrent.CopyOnWriteArrayList\""));
}
 

import hudson.model.Computer; //導入依賴的package包/類
public List<PermissionGroup> getGroups(String typeString) {
	AclType type = AclType.parseAclType(typeString);
	List<PermissionGroup> groups;
	switch (type) {
	case GLOBAL: {
		groups = new ArrayList<PermissionGroup>(
				PermissionGroup.getAll());
		groups.remove(PermissionGroup.get(Permission.class));
		break;
	}
	case PROJECT: {
		groups = new ArrayList<PermissionGroup>(
				PermissionGroup.getAll());
		groups.remove(PermissionGroup.get(Permission.class));
		groups.remove(PermissionGroup.get(Jenkins.class));
		groups.remove(PermissionGroup.get(Computer.class));
		groups.remove(PermissionGroup.get(View.class));
		break;
	}
	default:
		groups = null;
	}
	return groups;
}
 

import hudson.model.Computer; //導入依賴的package包/類
@Override
public Environment setUp(AbstractBuild build, Launcher launcher, BuildListener listener) throws IOException, InterruptedException {
	OpenEdgeInstallation installation = getOpenEdgeInstallation();
	if (installation != null) {
		installation = installation.forNode(Computer.currentComputer().getNode(), listener);
	}

	// Add DLC variable and modify PATH
	final OpenEdgeInstallation install = installation;
	return new Environment() {
		@Override
		public void buildEnvVars(Map<String, String> env) {
			if (install != null) {
				EnvVars envVars = new EnvVars();
				install.buildEnvVars(envVars);
				env.putAll(envVars);
			}
		}
	};
}
 

import hudson.model.Computer; //導入依賴的package包/類
@Override
public Collection<NodeProvisioner.PlannedNode> provision(Label label, int excessWorkload) {
    try {

        List<NodeProvisioner.PlannedNode> r = new ArrayList<NodeProvisioner.PlannedNode>();
        final ECSTaskTemplate template = getTemplate(label);

        for (int i = 1; i <= excessWorkload; i++) {

            r.add(new NodeProvisioner.PlannedNode(template.getDisplayName(), Computer.threadPoolForRemoting
                    .submit(new ProvisioningCallback(template, label)), 1));
        }
        return r;
    } catch (Exception e) {
        LOGGER.log(Level.WARNING, "Failed to provision ECS slave", e);
        return Collections.emptyList();
    }
}
 

import hudson.model.Computer; //導入依賴的package包/類
public static void attachFacet(Run<?, ?> run, TaskListener listener) {
    final Executor executor = run.getExecutor();
    if (executor == null) {
        return;
    }

    final Computer owner = executor.getOwner();
    DockerComputer dockerComputer;
    if (owner instanceof DockerComputer) {
        dockerComputer = (DockerComputer) owner;
        try {
            DockerFingerprints.addRunFacet(
                    createRecordFor(dockerComputer),
                    run
            );
        } catch (IOException | ParseException e) {
            listener.error("Can't add Docker fingerprint to run.");
            LOG.error("Can't add fingerprint to run {}", run, e);
        }
    }


}
 

import hudson.model.Computer; //導入依賴的package包/類
protected void done(final AbstractCloudComputer<?> c) {
    c.setAcceptingTasks(false); // just in case
    synchronized (this) {
        if (terminating) {
            return;
        }
        terminating = true;
    }

    final Future<?> submit = Computer.threadPoolForRemoting.submit(() -> {
            try {
                AbstractCloudSlave node = c.getNode();
                if (node != null) {
                    node.terminate();
                }
            } catch (InterruptedException | IOException e) {
                LOG.warn("Failed to terminate " + c.getName(), e);
                synchronized (DockerOnceRetentionStrategy.this) {
                    terminating = false;
                }
            }
        }
    );
}
 

import hudson.model.Computer; //導入依賴的package包/類
@Before
public void setup() throws IOException {
    // Define a Test Directory
    File localPath = File.createTempFile("TestGitRepository", "");

    // prepare a new folder
    if(localPath.exists()) localPath.delete();

    // create the repository
    repository = FileRepositoryBuilder.create(new File(localPath, ".git"));
    repository.create();

    // Setup Mocks
    when(build.getWorkspace()).thenReturn(new FilePath(new File(getClass().getResource("/").getPath())));
    when(listener.getLogger()).thenReturn(System.out);

    when(app.getName()).thenReturn("testapp");
    when(app.getGitUrl()).thenReturn(repository.getDirectory().getAbsolutePath());
    
    mockStatic(Computer.class);
    PowerMockito.when(Computer.currentComputer()).thenReturn(mock(MasterComputer.class));
    
}
 

import hudson.model.Computer; //導入依賴的package包/類
private synchronized void updateMetrics() {
    final Jenkins jenkins = Jenkins.getInstance();
    if (jenkins != null) {
        Set<Computer> forRetention = new HashSet<Computer>();
        for (Node node : jenkins.getNodes()) {
            Computer computer = node.toComputer();
            if (computer == null) {
                continue;
            }
            forRetention.add(computer);
            getOrCreateTimer(computer);
        }
        MetricRegistry metricRegistry = Metrics.metricRegistry();
        for (Map.Entry<Computer, Timer> entry : computerBuildDurations.entrySet()) {
            if (forRetention.contains(entry.getKey())) {
                continue;
            }
            // purge dead nodes
            metricRegistry.remove(name("jenkins", "node", entry.getKey().getName(), "builds"));
        }
        computerBuildDurations.keySet().retainAll(forRetention);
    }

}
 

import hudson.model.Computer; //導入依賴的package包/類
@Override
public synchronized void onStarted(Run run, TaskListener listener) {
    JenkinsMetricProviderImpl instance = instance();
    if (instance != null) {
        List<Timer.Context> contextList = new ArrayList<Timer.Context>();
        contextList.add(instance.jenkinsJobBuildingTime.time());
        Executor executor = run.getExecutor();
        if (executor != null) {
            Computer computer = executor.getOwner();
            Timer timer = instance.getOrCreateTimer(computer);
            contextList.add(timer.time());
        }
        contexts.put(run, contextList);
    }
    ScheduledRate.instance().addAction(run);
}
 

import hudson.model.Computer; //導入依賴的package包/類
@Override
@Exported
public Executor getExecutor() {
    final Jenkins jenkins = Jenkins.getInstance();
    if (jenkins == null) {
        return null;
    }
    for (final Computer computer : jenkins.getComputers()) {
        for (final Executor executor : computer.getExecutors()) {
            if (isCurrent(executor)) {
                return executor;
            }
        }
    }
    return null;
}
 

import hudson.model.Computer; //導入依賴的package包/類
private String getRawSepFor(Computer c) {
	if (c == null) { return null; }
	String sep = null;
	//Fetch via System properties
	try {
		Map<Object,Object> map = c.getSystemProperties();
		if (map != null && map.containsKey("file.separator")) {
			Object o = map.get("file.separator");
			if (o instanceof String) {
				sep = (String)o;
				if (sep.equals("\\") || sep.equals("/")) {
					return sep;
				}
			}
		}
	} catch (IOException | InterruptedException e) {
		return null;
	}
	return sep;
}
 

import hudson.model.Computer; //導入依賴的package包/類
public static void setLogLevel(Level level) {
    SupportPlugin instance = getInstance();
    instance.handler.setLevel(level);
    for (Node n : Jenkins.getInstance().getNodes()) {
        Computer c = n.toComputer();
        if (c == null) {
            continue;
        }
        VirtualChannel channel = c.getChannel();
        if (channel != null) {
            try {
                channel.callAsync(new LogUpdater(level));
            } catch (IOException e) {
                // ignore
            }
        }
    }
}
 

import hudson.model.Computer; //導入依賴的package包/類
@Override
public void run()
{
    Node node = Computer.currentComputer().getNode();
    LOGGER.info(String.format("%s was run on %s", DummySubTask.this.getDisplayName(), node.getNodeName()));
    
    try
    {
        Thread.sleep(DummySubTask.this.duration);
    }
    catch(InterruptedException e)
    {
        LOGGER.log(Level.SEVERE, "", e);
        return;
    }
    
    DummySubTask.this.lastBuiltOn = node;
}
 

import hudson.model.Computer; //導入依賴的package包/類
@Override
public void onOnline(Computer c, TaskListener listener) throws IOException,
        InterruptedException {
    // gets called when master goes into online state
    // gets called when existing slave re-connects
    // gets called when new slave goes into online state
    logger.info("---- " + ComputerListenerImpl.class.getName() + ":"
            + " onOnline computer " + c);

    // update functions only when gearman-plugin is enabled
    if (!GearmanPluginConfig.get().enablePlugin()) {
        return;
    }

    GearmanProxy gp = GearmanProxy.getInstance();
    /*
     * Spawn management executor worker if one doesn't exist yet.
     * This worker does not need any executors. It only needs
     * to work with gearman.
     */
    gp.createManagementWorker();

    // on creation of new slave
    gp.createExecutorWorkersOnNode(c);
}