import hudson.slaves.JNLPLauncher; //导入依赖的package包/类
@Test
public void should_connect_agent() throws InterruptedException, ExecutionException, IOException, URISyntaxException {

    final JenkinsLocationConfiguration location = JenkinsLocationConfiguration.get();
    URI uri = URI.create(location.getUrl());
    if (SystemUtils.IS_OS_MAC) {
        uri = new URI(uri.getScheme(), uri.getUserInfo(), "docker.for.mac.localhost",
                uri.getPort(), uri.getPath(), uri.getQuery(), uri.getFragment());
    } else if (SystemUtils.IS_OS_WINDOWS) {
        uri = new URI(uri.getScheme(), uri.getUserInfo(), "docker.for.windows.localhost",
                uri.getPort(), uri.getPath(), uri.getQuery(), uri.getFragment());
    }

    final DockerTemplate template = new DockerTemplate(
            new DockerTemplateBase("jenkins/jnlp-slave"),
            new DockerComputerJNLPConnector(new JNLPLauncher(null, null)).withUser("jenkins")
                    .withJenkinsUrl(uri.toString()),
            "docker-agent", "/home/jenkins/agent", "10"
    );

    if (SystemUtils.IS_OS_LINUX) {
        template.getDockerTemplateBase().setNetwork("host");
    }

    should_connect_agent(template);
}
 

import hudson.slaves.JNLPLauncher; //导入依赖的package包/类
@Override
public boolean isLaunchSupported() {
    //TODO: Add this into the settings for node setup
    boolean overrideLaunchSupported = delegate.isLaunchSupported();
    //Support launching for the JNLPLauncher, so the `launch` function gets called
    //and the VM can be reset to a snapshot.
    if (delegate instanceof JNLPLauncher) {
        overrideLaunchSupported = true;
    }
    return overrideLaunchSupported;
}
 

import hudson.slaves.JNLPLauncher; //导入依赖的package包/类
public Node call() throws Exception {

            ECSSlave slave = new ECSSlave(ECSCloud.this, name + "-" + UUID.randomUUID().toString(), template.getRemoteFSRoot(), label == null ? null: label.toString(), new JNLPLauncher());
            Jenkins.getInstance().addNode(slave);
            LOGGER.log(Level.INFO, "Created Slave: {0}", slave.getNodeName());

            Collection<String> command = getDockerRunCommand(slave);
            final RegisterTaskDefinitionRequest req = template.asRegisterTaskDefinitionRequest(command);

            final AmazonECSClient client = new AmazonECSClient(getCredentials(credentialsId));
            final RegisterTaskDefinitionResult result = client.registerTaskDefinition(req);
            String definitionArn = result.getTaskDefinition().getTaskDefinitionArn();
            LOGGER.log(Level.FINE, "Slave {0} - Created Task Definition {1}: {2}", new Object[] { slave.getNodeName(), definitionArn, req });
            LOGGER.log(Level.INFO, "Slave {0} - Created Task Definition: {1}", new Object[] { slave.getNodeName(), definitionArn });
            slave.setTaskDefinitonArn(definitionArn);

            final RunTaskResult runTaskResult = client.runTask(new RunTaskRequest()
                    .withTaskDefinition(definitionArn)
                    .withCluster(cluster)
            );

            if (! runTaskResult.getFailures().isEmpty()) {
                for (Failure failure : runTaskResult.getFailures()) {
                    LOGGER.log(Level.WARNING, "Slave {0} - {1} : {2}", new Object[] { slave.getNodeName(), failure.getReason(), failure.getArn() });
                }
                throw new IOException("Failed to run slave container " + slave.getNodeName());
            }

            String taskArn = runTaskResult.getTasks().get(0).getTaskArn();
            LOGGER.log(Level.INFO, "Slave {0} - Slave Task Started : {1}", new Object[] {slave.getNodeName(),  taskArn});
            slave.setTaskArn(taskArn);

            int i = 0;
            int j = 100; // wait 100 seconds

            // now wait for slave to be online
            for (; i < j; i++) {
                if (slave.getComputer() == null) {
                    throw new IllegalStateException("Slave " + slave.getNodeName() + " - Node was deleted, computer is null");
                }
                if (slave.getComputer().isOnline()) {
                    break;
                }
                LOGGER.log(Level.FINE, "Waiting for slave {0} to connect ({2}/{3}): {1}", new Object[] { slave.getNodeName(), taskArn, i, j});
                Thread.sleep(1000);
            }
            if (!slave.getComputer().isOnline()) {
                throw new IllegalStateException("ECS Slave " + slave.getNodeName() + "is not connected after " + j + " seconds");
            }

            LOGGER.log(Level.INFO, "ECS Slave " + slave.getNodeName() + " connected: {0}", taskArn);
            return slave;
        }
 

import hudson.slaves.JNLPLauncher; //导入依赖的package包/类
@DataBoundConstructor
public DockerLauncher(String execUser) {
	super(new JNLPLauncher());
	this.execUser = execUser;
}
 

import hudson.slaves.JNLPLauncher; //导入依赖的package包/类
private Slave createLinuxSlave(String name, String description, String label) throws Exception {
    return new DumbSlave(name, description, "/wherever", "1", Node.Mode.NORMAL, label, new JNLPLauncher(), RetentionStrategy.NOOP, Collections.<NodeProperty<?>>emptyList());
}
 

import hudson.slaves.JNLPLauncher; //导入依赖的package包/类
private Slave createSlave(String name, String description, String label) throws Exception {
    return new DumbSlave(name, description, "/wherever", "1", Node.Mode.NORMAL, label, new JNLPLauncher(), RetentionStrategy.NOOP, Collections.<NodeProperty<?>>emptyList());
}
 

import hudson.slaves.JNLPLauncher; //导入依赖的package包/类
private Slave createSlave(String name, String description) throws Exception {
    return new DumbSlave(name, description, "/wherever", "1", Node.Mode.NORMAL, null, new JNLPLauncher(), RetentionStrategy.NOOP, Collections.<NodeProperty<?>>emptyList());
}
 

import hudson.slaves.JNLPLauncher; //导入依赖的package包/类
@Override
public ComputerLauncher getLauncher() {
    return new JNLPLauncher();
}
 

import hudson.slaves.JNLPLauncher; //导入依赖的package包/类
public Class getJNLPLauncher() {
    return JNLPLauncher.class;
}
 

import hudson.slaves.JNLPLauncher; //导入依赖的package包/类
@DataBoundConstructor
public DockerComputerJNLPConnector(JNLPLauncher jnlpLauncher) {
    this.jnlpLauncher = jnlpLauncher;
}
 

import hudson.slaves.JNLPLauncher; //导入依赖的package包/类
public JNLPLauncher getJnlpLauncher() {
    return jnlpLauncher;
}
 

import hudson.slaves.JNLPLauncher; //导入依赖的package包/类
@Override
protected ComputerLauncher createLauncher(final DockerAPI api, final String workdir, final InspectContainerResponse inspect, TaskListener listener) throws IOException, InterruptedException {
    return new JNLPLauncher();
}