1、public class HyperSlaves extends Plugin implements Describable<HyperSlaves>
（1）、init()：初始化containerDriverFactory，其中的containerDriverFactory是一个抽象类ContainerDriverFactory类型的变量，我们可以调用它的forJob(Job context)方法获得一个ContainerDriver类型的抽象类。
（2）、createStandardJobProvisionerFactory(job)： 其中调用return new HyperProvisionerFactory.StandardJob(...)来返回一个HyperProvisionerFactory的抽象类
2、public abstract class HyperProvisionerFactory
作用：准备workspace，再返回一个HyperProvisioner实例
（1）、其中包含一个抽象方法public abstract HyperProvisioner createProvisioner(TaskListener slaveListener)，其中内部类StandardJob实现了本抽象类，其中的createProvisioner函数先创建一个JobBuildsContainersContext类的实例context,再调用prepareWorkspace(job, context)，最后调用return new HyperProvisioner(context, slaveListener, driver, job, spec)
3、public abstract class OneShotSlave extends Slave implements EphemeralNode
作用：A slave that is designed to be used only once, for a specific hudson.model.Run，and as such has a life cycle to fully match the Run's one
provisioning such a slave should be a lightweight process, so one can provision them at any time and concurrently to match hudson.model.Queue load.
Typically usage is Docker container based Jenkins agents
Actual launch of the Slave is postponed until a Run is created, so we can have a 1:1 match between Run and Executor lifecycle:
dump the launch log in build log
mark the build as NOT_BUILD on launch failed
shut down and remove the Executor on build completion
变量：private transient Queue.Executable executable
private final ComputerLauncher realLauncher;
private boolean provisioningFailed = false;
（1）、public Launcher createLauncher(TaskListener listener)：该函数先调用provision(listener)，再调用return super.createLauncher(listener)
// Assign a Queue.Executable to this OneShotSlave.By design, only one Queue.Executable can be assigned, then slave is shut down.
This method has to be called just as the Run as been created. It run the actual launch of the executor
and use Run's hudson.model.BuildListener as computer launcher listener to collect the startup log as part of the build
Delaying launch of the executor until the Run is actually started allows to fail the build on launch failure
so we have a strong 1:1 relation between a Run and its Executor
（2）、首先调用创建 Executor类：executor = Executor.currentExecutor()，再调用realLauncher.launch(this.getComputer(), listener)启动一个slave容器
如果之后调用getComputer().isActuallyOffline()为true，则调用provisionFailed(new IllegalStateException("Computer is offline after launch"))
最后，如果没有异常发生，则调用executable = executor.getCurrentExecutable()
3、public class HyperSlave extends OneShotSlave
// EphemeralNode使用hyper container来运行build process，Slave只专注于一个特定的Job，最好专注于一个特定的build，但是在本类刚刚创建的时候，因为jenkins的生存周期，build还不存在。
private final HyperProvisionerFactory provisionerFactory
（1）、构造函数为：public HyperSlave(String name, String nodeDescription, String labelString, HyperProvisionerFactory provisionerFactory)：
先调用super(name.replaceAll("/", ">>"), nodeDescription, SLAVE_ROOT, labelString, new HyperComputerLauncher())初始化父类
（2）、public HyperComputer createComputer()：该函数只是简单地调用new HyperComputer(this, provisionerFactory)
// Create a custom Launcher which relies on "docker run" to start a new process
（3）、public Launcher createLauncher(TaskListener listener)：该方法先调用c = getComputer()获取HyperComputer类，再调用super.createLauncher(listener)，最后调用launcher = new HyperLauncher(listener, c.getChannel(), c.isUnix(), c.getProvisioner()).decorateFor(this)，生成一个launcher并返回。
3、public abstract class OneShotComputer extends SlaveComputer
private final OneShotSlave slave
（1） 、构造函数：public OneShotComputer(OneShotSlave slave)：调用super(slave)构造父类，再调用this.slave = slave
// Claim we are online so we get task assigned to the executor, so a Run is created then can actually launch and report provisioning status in the build log
（2）、public boolean isOffline()：当slave不为空时，如果slave.hasProvisioningFailed()为true，则返回true，否则如果slave.hasExecutable()为false，则返回false
否则，return isAcutallyOffline()
（3）、public boolean isAcutallyOffline()：仅仅调用return super.isOffline()
4、public class HyperComputer extends OneShotComputer
private final HyperSlave slave;
private final HyperProvisionerFactory provisionerFactory;
private HyperProvisioner
（1）、构造函数为：public HyperComputer(HyperSlave slave, HyperProvisionerFactory provisionerFactory)，利用slave初始化父类，再分别给slave和provisionerFactory赋值
// Create a container provisioner to setup this Jenkins "computer" (aka executor)
（2）、public HyperProvisioner createProvisioner()：该函数调用 provisioner = provisionerFactory.createProvisioner(getListener())，并返回provisioner
（3）、public ComputerLauncher createComputerLauncher()：该函数仅仅new并返回一个HyperComputerLauncher()
5、public class HyperProvisioner
作用：创建slave容器，并且之后的exec操作也是通过本类进行
protected final JobBuildsContainersContext context;
protected final TaskListener slaveListener;
protected final ContainerDriver driver;
protected final Launcher launcher;
protected final ContainerSetDefinition spec;
（1）、构造函数为：public HyperProvisioner(JobBuildsContainersContext context, TaskListener slaveListenerm, ContainerDriver driver, Job job, ContainerSetDefinition spec)
该类中的多数变量都直接赋值，其中this.launcher = new Launcher.LocalLauncher(slaveListener)
（2）、public void prepareAndLaunchSlaveContainer(final SlaveComputer computer, TaskListener listener)：该函数先判断slave container是否存在，如果存在则重用。
否则，首先获取buildImage和containerSize，再调用final ContainerInstance slaveContainer = driver.createAndLaunchSlaveContainer(computer, launcher, buildImage, containerSize)生成一个容器实例，最后调用context.setSlaveContainer(slaveContainer)将slave container加入上下文。
（3）、public Proc launchBuildProcess(Launcher.ProcStarter procStarter, TaskListener)：该函数仅仅调用return driver.execInSlaveContainer(launcher, context.getSlaveContainer().getId(), procStarter)
6、public class HyperComputerLauncher extends ComputerLauncher
作用：启动slave容器
（1）、public void launch(final SlaveComputer computer, TaskListener listener)：launch容器的之前之后，添加一些log，再调用launch((HyperComputer) computer, listener)
（2）、public void launch(final HyperComputer computer, TaskListener listener)：该函数先调用provisioner=computer.createProvisioner()的HyperProvisioner类的实例，再调用provisioner.prepareAndLaunchSlaveContainer(computer, listener)来生成slave container
7、public class HyperLauncher extends Launcher.DecoratedLauncher
作用：Process launcher which uses docker exec instead of execve
Jenkins relies on remoting channel to run commands/process on executor.As Docker can as well be used to run a process remotely ,we can just bypass remoting
private final HyperProvisioner provisioner
（1）、构造函数为：public HyperLauncher(TaskListener listener, VirtualChannel channel, boolean isUnix, HyperProvisioner provisioner)：
首先调用super(new Launcher.RemoteLauncher(listener, channel, isUnix))对父类进行构造，再调用this.provisioner = provisioner
（2）、public Proc launch(ProcStarter starter)：该方法仅仅调用return provisioner.launchBuildProcess(starter, listener)
----------------------------------------------------------------------------- jenkins 源码 -------------------------------------------------------------------------------------------
1、public class CommandLauncher extends Computer
private final String agentCommand; // Command line to launch the agent, like "ssh myslave java -jar /path/to/hudson-remoting.jar"
private final EnvVars env; // Optional environment variables to add the current environment. Can be null
（1）、public void launch(SlaveComputer computer, fijnal TaskListener listener)：首先调用Slave node = computer.getNode()，当node为null时报错
构建ProcessBuilder pb = new ProcessBuilder(Util.tokenize(getCommand()))，再在其中注入HUDSON_URL, JENKINS_URL, SLAVEJAR_URL等环境变量
调用final Process proc = _proc = pb.start()，最后调用computer.setChannel(proc.getInputStream(), proc.getOutputStream(), listener.getLogger(), new Channel.Listener() {...})建立channel
2、