Java Callable类代码示例

import hudson.remoting.Callable; //导入依赖的package包/类
public static Callable<?, ?> getPropertyCallable ( final Object prop )
        throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
    Class<?> reqClass = Class.forName("hudson.remoting.RemoteInvocationHandler$RPCRequest");
    Constructor<?> reqCons = reqClass.getDeclaredConstructor(int.class, Method.class, Object[].class);
    reqCons.setAccessible(true);
    Object getJarLoader = reqCons
            .newInstance(1, Class.forName("hudson.remoting.IChannel").getMethod("getProperty", Object.class), new Object[] {
                prop
    });
    return (Callable<?, ?>) getJarLoader;
}
 

import hudson.remoting.Callable; //导入依赖的package包/类
public static boolean executeWithGitSSH(BuildContext context, SSHUserPrivateKey creds, EnvVars envVars, Callable<Boolean, Exception> callable) throws Exception {
    context.listener.getLogger().println("using GIT_SSH to set credentials " + creds.getDescription());

    FilePath key = createSshKeyFile(context.build.getWorkspace(), creds);
    FilePath ssh = null;
    FilePath pass = null;;

    try {
        if (context.launcher.isUnix()) {
            ssh = createUnixGitSSH(context.build.getWorkspace(), key, creds.getUsername());
            pass = createUnixSshAskpass(context.build.getWorkspace(), creds);
        } else {
            ssh = createWindowsGitSSH(context.build.getWorkspace(), key, creds.getUsername(), envVars);
            pass = createWindowsSshAskpass(context.build.getWorkspace(), creds);
        }

        envVars.put("GIT_SSH", ssh.getRemote());
        envVars.put("SSH_ASKPASS", pass.getRemote());

        if (!envVars.containsKey("DISPLAY")) {
            envVars.put("DISPLAY", ":");
        }

        return callable.call();

    } finally {
        tryDelete(key, context.listener);
        tryDelete(ssh, context.listener);
        tryDelete(pass, context.listener);
    }
}
 

import hudson.remoting.Callable; //导入依赖的package包/类
public static boolean runGit(final BuildContext context, final List<String> args, final EnvVars envVars, boolean withAuth) throws Exception, BuildInterruptedException {
    Callable<Boolean, Exception> gitRunner = new Callable<Boolean, Exception>() {
        @Override
        public Boolean call() throws Exception {
            final String gitExe;
            if (JenkinsHelper.isNodeWindows(context)) {
                gitExe = "git.exe";
            } else {
                gitExe = "git";
            }

            // prepend 'git' to the command line args
            args.add(0, gitExe);

            return JenkinsHelper.execute(context, args, envVars);
        }
    };

    if (withAuth) {
        // find the credentials.
        SSHUserPrivateKey theCreds = GitSSHKeyHelper.getSSHCredentials(context, envVars);
        if (theCreds == null) {
            context.listener.getLogger().println("No SSH credentials found");
            return false;
        }

        return GitSSHKeyHelper.executeWithGitSSH(context, theCreds, envVars, gitRunner);
    } else {
        return gitRunner.call();
    }
}
 

import hudson.remoting.Callable; //导入依赖的package包/类
public static Boolean caller(DockerCLI cli, Callable<Boolean, Throwable> callable) throws Throwable {
    LOG.trace("Calling callable '{}'.", callable);
    assertThat(cli.getChannel(), notNullValue());
    Boolean call = cli.getChannel().call(callable);
    assertThat(call, is(true));
    return call;
}
 

import hudson.remoting.Callable; //导入依赖的package包/类
/**
 * Get executable path of this Drush installation on the given target system.
 */
public String getExecutable(Launcher launcher) throws IOException, InterruptedException {
    return launcher.getChannel().call(new Callable<String,IOException>() {
        public String call() throws IOException {
            File exe = getExeFile();
            return exe.exists() ? exe.getPath() : null;
        }
    });
}
 

import hudson.remoting.Callable; //导入依赖的package包/类
private void initiateDownloadsAtWorkspace(
    final GoogleRobotCredentials credentials,
    final Run run, final List<StorageObjectId> objects,
    final FilePath localDir, final TaskListener listener,
    final String version, final String resolvedPrefix)
    throws IOException, InterruptedException {
  try {
    // Use remotable credential to access the storage service from the
    // remote machine.
    final GoogleRobotCredentials remoteCredentials =
        checkNotNull(credentials).forRemote(module.getRequirement());

    localDir.act(
        new Callable<Void, IOException>() {
          @Override
          public Void call() throws IOException {
            performDownloads(remoteCredentials, localDir, objects, listener,
                version, resolvedPrefix);
            return (Void) null;
          }

          @Override
          public void checkRoles(RoleChecker checker)
              throws SecurityException {
            // We know by definition that this is the correct role;
            // the callable exists only in this method context.
          }
        });
  } catch (GeneralSecurityException e) {
    throw new IOException(
        Messages.AbstractUpload_RemoteCredentialError(), e);
  }
}
 

import hudson.remoting.Callable; //导入依赖的package包/类
public String getExecutable(Launcher launcher) throws InterruptedException, IOException {
    return launcher.getChannel().call(new Callable<String, IOException>() {
        public String call() throws IOException {
            File exe = getExeFile();
            if (exe.exists()) {
                return exe.getPath();
            }
            return null;
        }
    });
}
 

import hudson.remoting.Callable; //导入依赖的package包/类
public String getExecutable(Launcher launcher) throws IOException, InterruptedException
{
    return launcher.getChannel().call(new Callable<String,IOException>()
    {
        @Override
        public String call() throws IOException
        {
            File fauxpasFile = new File(getHome(), "fauxpas");
            return fauxpasFile.exists() ? fauxpasFile.getPath() : null;
        }
    });
}
 

import hudson.remoting.Callable; //导入依赖的package包/类
public String getExecutable(Launcher launcher) throws IOException,
		InterruptedException {
	return launcher.getChannel().call(
			new Callable<String, IOException>() {
				private static final long serialVersionUID = 1L;

				public String call() throws IOException {
					File exe = getExeFile();
					if (exe.exists())
						return exe.getPath();
					return null;
				}
			});
}
 

import hudson.remoting.Callable; //导入依赖的package包/类
/**
 * Gets the executable path of this groovy installation on the given target system.
 */
public String getExecutable(final Launcher launcher, final VirtualChannel channel) throws IOException, InterruptedException {
    return channel.call(new Callable<String, IOException>() {
        @Override
        public String call() throws IOException {
            final File exe = getExePath("scala", launcher.isUnix());
            if(exe.exists()) {
                return exe.getPath();
            }
            return null;
        }
    });
}
 

import hudson.remoting.Callable; //导入依赖的package包/类
public static <V, T extends java.lang.Throwable> V get(Node node, WeakHashMap<Node, V> cache, /*MasterToSlave*/Callable<V,T> operation, String name, V defaultIfNull)

            throws IOException {
        V result = get(node, cache, operation, name);
        return result == null ? defaultIfNull : result;
    }