hudson.model.Executor#getOwner ( )源码实例Demo

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


}
 

protected void done(Executor executor) {
    final AbstractCloudComputer<?> c = (AbstractCloudComputer) executor.getOwner();
    Queue.Executable exec = executor.getCurrentExecutable();
    if (executor instanceof OneOffExecutor) {
        LOG.debug("Not terminating {} because {} was a flyweight task", c.getName(), exec);
        return;
    }

    if (exec instanceof ContinuableExecutable && ((ContinuableExecutable) exec).willContinue()) {
        LOG.debug("not terminating {} because {} says it will be continued", c.getName(), exec);
        return;
    }

    LOG.debug("terminating {} since {} seems to be finished", c.getName(), exec);
    done(c);
}
 

private void done(Executor executor) {
    final DockerSwarmComputer c = (DockerSwarmComputer) executor.getOwner();
    Queue.Executable exec = executor.getCurrentExecutable();
    if (exec instanceof ContinuableExecutable && ((ContinuableExecutable) exec).willContinue()) {
        LOGGER.log(Level.FINE, "not terminating {0} because {1} says it will be continued",
                new Object[] { c.getName(), exec });
        return;
    }
    LOGGER.log(Level.FINE, "terminating {0} since {1} seems to be finished", new Object[] { c.getName(), exec });
    done(c);
}
 

private void done(Executor executor) {
    final DockerComputer c = (DockerComputer) executor.getOwner();
    Queue.Executable exec = executor.getCurrentExecutable();
    if (exec instanceof ContinuableExecutable && ((ContinuableExecutable) exec).willContinue()) {
        LOGGER.log(Level.FINE, "not terminating {0} because {1} says it will be continued", new Object[]{c.getName(), exec});
        return;
    }
    LOGGER.log(Level.FINE, "terminating {0} since {1} seems to be finished", new Object[]{c.getName(), exec});
    done(c);
}
 

private PrintStream getLogger(Executor executor) {
    final DockerSwarmComputer c = (DockerSwarmComputer) executor.getOwner();
    return c.getListener().getLogger();
}
 

@Override
public void buildEnvironmentFor(@Nonnull Run run, @Nonnull EnvVars envs, @Nonnull TaskListener listener)
        throws IOException, InterruptedException {
    final Executor executor = run.getExecutor();
    if (executor != null && executor.getOwner() instanceof DockerComputer) {
        final DockerComputer dockerComputer = (DockerComputer) executor.getOwner();
        DockerSlave node = dockerComputer.getNode();
        if (isNull(node)) {
            LOG.debug("{} is missing it's node, skipping...", dockerComputer.getName());
            return;
        }

        final DockerNodeProperty dProp = node.getNodeProperties().get(DockerNodeProperty.class);
        if (dProp == null) {
            return;
        }

        if (dProp.isContainerIdCheck()) {
            listener.getLogger().println("[YAD-PLUGIN] Injecting variable: " + dProp.getContainerId());
            envs.put(dProp.getContainerId(), dockerComputer.getContainerId());
        }

        if (dProp.isCloudIdCheck()) {
            listener.getLogger().println("[YAD-PLUGIN] Injecting variable: " + dProp.getCloudId());
            envs.put(dProp.getCloudId(), dockerComputer.getCloudId());
        }

        if (dProp.isDockerHostCheck()) {
            try {
                //replace http:// and https:// from docker-java to tcp://
                final DockerCloud cloud = dockerComputer.getCloud(); // checkfornull
                if (cloud != null && cloud.getConnector() != null) {
                    final URIBuilder uriBuilder = new URIBuilder(cloud.getConnector().getServerUrl());
                    if (!uriBuilder.getScheme().equals("unix")) {
                        uriBuilder.setScheme("tcp");
                    }

                    listener.getLogger().println("[YAD-PLUGIN] Injecting variable: " + dProp.getDockerHost());
                    envs.put(dProp.getDockerHost(), uriBuilder.toString());
                }
            } catch (URISyntaxException e) {
                listener.error("Can't make variable: %s", dProp.getDockerHost(), e);
                LOG.error("Can't make '{}' variable: {}", dProp.getDockerHost(), e);
            }
        }
    }
}