import org.jclouds.compute.domain.ExecResponse; //导入依赖的package包/类
/**
 * Returns true if fixing /etc/sudoers (disabling "Defaults requiretty" configuration option) is required for given Node.
 *
 * @param node Node to check
 * @param jcloudsSshClient SSH client instance
 * @return true if fix is required by node configuration and "/etc/sudoers" file exists, false otherwise
 */
private boolean isSudoersFixRequired(AbstractJCloudsNode<?> node, org.jclouds.ssh.SshClient jcloudsSshClient) {
    final String fixSudoersPropertyName = node.getCloudProvider().getProviderSpecificPropertyName(node.config(),
            Config.Node.Shared.SSH_FIX_SUDOERS);

    // check if fixing /etc/sudoers is requested in Node configuration
    if (node.config().getPropertyAsBoolean(fixSudoersPropertyName, false)) {
        // check if /etc/sudoers exists on the Node
        ExecResponse sudoersResult = jcloudsSshClient
                .exec("sh -c '" + SshUtils.FileType.getShellTestStr("/etc/sudoers") + "'");
        SshUtils.FileType sudoersFile = SshUtils.FileType.fromExitCode(sudoersResult.getExitStatus());
        if (sudoersFile == SshUtils.FileType.FILE) {
            return true;
        }
    }
    return false;
}
 

import org.jclouds.compute.domain.ExecResponse; //导入依赖的package包/类
/**
 * Make sure you've unmounted the volume first. Failure to do so could result in failure or data loss.
 */
private void unmountVolume(VolumeAttachment volumeAttachment) {
   System.out.format("Unmount Volume%n");

   String script = new ScriptBuilder().addStatement(exec("umount /mnt")).render(OsFamily.UNIX);

   RunScriptOptions options = RunScriptOptions.Builder
         .overrideLoginUser(ROOT)
         .overrideLoginPassword(PASSWORD)
         .blockOnComplete(true);

   RegionAndId regionAndId = RegionAndId.fromRegionAndId(REGION, volumeAttachment.getServerId());
   ExecResponse response = computeService.runScriptOnNode(regionAndId.slashEncode(), script, options);

   if (response.getExitStatus() == 0) {
      System.out.format("  Exit Status: %s%n", response.getExitStatus());
   }
   else {
      System.out.format("  Error: %s%n",response.getOutput());
   }
}
 

import org.jclouds.compute.domain.ExecResponse; //导入依赖的package包/类
private void mountVolume(NodeMetadata node) {
   System.out.format("Mount Volume and Create Filesystem%n");

   String script = new ScriptBuilder()
         .addStatement(exec("mkfs -t ext4 /dev/xvdd"))
         .addStatement(exec("mount /dev/xvdd /mnt"))
         .render(OsFamily.UNIX);

   RunScriptOptions options = RunScriptOptions.Builder
         .blockOnComplete(true)
         .overrideLoginPassword(PASSWORD);

   ExecResponse response = computeService.runScriptOnNode(node.getId(), script, options);

   if (response.getExitStatus() == 0) {
      System.out.format("  Exit Status: %s%n", response.getExitStatus());
   }
   else {
      System.out.format("  Error: %s%n", response.getOutput());
   }
}
 

import org.jclouds.compute.domain.ExecResponse; //导入依赖的package包/类
private static void runScriptOnGroup(final ComputeService compute,
                                     final LoginCredentials login, final String groupName, final Statement command)
        throws RunScriptOnNodesException {
    // when you run commands, you can pass options to decide whether
    // to run it as root, supply or own credentials vs from cache,
    // and wrap in an init script vs directly invoke
    Map<? extends NodeMetadata, ExecResponse> execResponses =
            compute.runScriptOnNodesMatching(//
                    inGroup(groupName), // predicate used to select nodes
                    command, // what you actually intend to run
                    overrideLoginCredentials(login)); // use the local user & ssh key

    for (Entry<? extends NodeMetadata, ExecResponse> response : execResponses.entrySet()) {
        System.out.printf(
                "<< node %s: %s%n",
                response.getKey().getId(),
                concat(response.getKey().getPrivateAddresses(), response.getKey()
                        .getPublicAddresses())
        );
        System.out.printf("<<     %s%n", response.getValue());
    }
}
 

import org.jclouds.compute.domain.ExecResponse; //导入依赖的package包/类
public static ExecResult exec(SshClient sshClient, String... command) throws OperationNotSupportedException {
    // note that this is much better than ComputeService.runScriptOnNode, which uses a monstrous script
    // that embeds the 'command' and messes up with the exit code

    StringBuilder stringBuilder = new StringBuilder();
    for (String string : command) {
        stringBuilder.append('\'').append(string).append('\'').append(" ");
    }
    ExecResponse execResponse = sshClient.exec(stringBuilder.toString());
    sshClient.disconnect();
    return new DefaultExecResult(execResponse.getOutput(), execResponse.getError(), execResponse.getExitStatus());
}
 

import org.jclouds.compute.domain.ExecResponse; //导入依赖的package包/类
@Test
    public void testLaunchClusterWithDomainName() throws RunNodesException {
        final String name = "test";

        Template template = view.getComputeService().templateBuilder()
                .osFamily(OsFamily.UBUNTU)
                .locationId("NA9")
                //.minRam(8192)
                //.locationId("NA12")
                .build();

        DimensionDataCloudControllerTemplateOptions options = template.getOptions().as(DimensionDataCloudControllerTemplateOptions.class);
        options
                .inboundPorts(22, 8080, 8081)
                .runScript(AdminAccess.standard())
                .networkDomainId("91f577d2-5812-4e39-a79f-a35e42eb78a6")
                .vlanId("025c59d7-b7e5-4261-95b8-4af067233ee7");

        try {
            Set<? extends NodeMetadata> nodes = view.getComputeService().createNodesInGroup(name, NUM_NODES, template);
            assertThat(nodes).hasSize(NUM_NODES);

            Map<? extends NodeMetadata, ExecResponse> responses = view.getComputeService().runScriptOnNodesMatching(runningInGroup(name), "echo hello");
            assertThat(responses).hasSize(NUM_NODES);

            for (ExecResponse execResponse : responses.values()) {
                assertThat(execResponse.getOutput().trim()).isEqualTo("hello");
            }
        } catch (RunScriptOnNodesException e) {
            Assert.fail();
        } finally {
            view.getComputeService().destroyNodesMatching(inGroup(name));
        }
}
 

import org.jclouds.compute.domain.ExecResponse; //导入依赖的package包/类
/**
 * Runs a script on the target node.
 */
protected void runScriptOnNode(Exchange exchange) throws CamelException {
    String script = exchange.getIn().getBody(String.class);
    String nodeId = getNodeId(exchange);
    String user = getUser(exchange);

    LoginCredentials credentials = null;

    if (ObjectHelper.isNotEmpty(user)) {
        credentials = LoginCredentials.builder().user(user).build();
    }
    ExecResponse execResponse = null;

    if (credentials == null) {
        execResponse = computeService.runScriptOnNode(nodeId, script);
    } else {
        execResponse = computeService.runScriptOnNode(nodeId, script, RunScriptOptions.Builder.overrideLoginCredentials(credentials).runAsRoot(false));
    }

    if (execResponse == null) {
        throw new CamelExchangeException("Failed to receive response for run script operation on node: " + nodeId + " using script: " + script, exchange);
    }

    exchange.setProperty(JcloudsConstants.RUN_SCRIPT_ERROR, execResponse.getError());
    exchange.setProperty(JcloudsConstants.RUN_SCRIPT_EXIT_CODE, execResponse.getExitStatus());
    exchange.getOut().setBody(execResponse.getOutput());
}
 

import org.jclouds.compute.domain.ExecResponse; //导入依赖的package包/类
/**
 * Logs the script output
 * @param data the results
 * @return the result for further processing
 */
private Map<? extends NodeMetadata, ExecResponse> log(Map<? extends NodeMetadata, ExecResponse> data) {
	for (NodeMetadata node : data.keySet()) {
		log(node, data.get(node));
	}
	return data;
}
 

import org.jclouds.compute.domain.ExecResponse; //导入依赖的package包/类
@Subscribe
@AllowConcurrentEvents
public void onSuccess(StatementOnNodeCompletion event) {
   ExecResponse arg0 = event.getResponse();
   if (arg0.getExitStatus() != 0) {
      logger.error("<< error running {} on node({}): {}", new Object[] { event.getStatement(), event.getNode().getId(),
            arg0 });
   } else {
      logger.info("<< success executing {} on node({}): {}", new Object[] { event.getStatement(),
            event.getNode().getId(), arg0 });
   }
}
 

import org.jclouds.compute.domain.ExecResponse; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public Map<NodeMetadata, String> stdoutFromCommandOnGroup(String command, String group) {
   try {
      return transformValues((Map<NodeMetadata, ExecResponse>) compute.runScriptOnNodesMatching(
            runningInGroup(group), command, asCurrentUser().wrapInInitScript(false)), getStdout());
   } catch (RunScriptOnNodesException e) {
      throw propagate(e);
   }
}
 

import org.jclouds.compute.domain.ExecResponse; //导入依赖的package包/类
public static Function<ExecResponse, String> getStdout() {
   return new Function<ExecResponse, String>() {

      @Override
      public String apply(ExecResponse input) {
         return input.getOutput();
      }
   };
}
 

import org.jclouds.compute.domain.ExecResponse; //导入依赖的package包/类
/**
 * Copies a remote file or folder to the local machine.
 *
 * @param remoteSrc path to remote file of folder
 * @param localTarget path to local folder, or, if {@code remoteSrc} is a file, also a file
 * @throws OperationNotSupportedException if this node implementation doesn't provide ssh access
 * @throws IllegalArgumentException if {@code remoteSrc} is a folder and {@code localTarget} is a regular file or if
 *         {@code remoteSrc} is an empty string
 * @throws NullPointerException if {@code remoteSrc} or {@code localTarget} is {@code null}.
 * @throws FileNotFoundException if {@code remoteSrc} does not exist
 */
@Override
public void copyFileFromNode(String remoteSrc, Path localTarget) throws OperationNotSupportedException,
        IllegalArgumentException, NullPointerException, IOException, InterruptedException {
    if (remoteSrc == null || localTarget == null) {
        throw new NullPointerException("Remote path and local path can't be null.");
    }
    if (Strings.isNullOrEmpty(remoteSrc)) {
        throw new IllegalArgumentException("Remote path must not be empty.");
    }

    SunstoneCoreLogger.SSH.debug("Copying remote path '{}' on node '{}' to local target '{}'", remoteSrc, getName(),
            localTarget);

    SshUtils.FileType remoteFileType = SshUtils.FileType
            .fromExitCode(exec("sh", "-c", SshUtils.FileType.getShellTestStr(remoteSrc)).getExitCode());
    if (remoteFileType == SshUtils.FileType.NA) {
        throw new FileNotFoundException("Source file " + remoteSrc + " doesn't exist in node " + getName());
    }

    SshUtils.FileType localFileType = SshUtils.FileType.fromPath(localTarget);
    if (localFileType == SshUtils.FileType.FILE && remoteFileType == SshUtils.FileType.DIRECTORY) {
        throw new IllegalArgumentException(
                "Unable to copy remote directory " + remoteSrc + " to local regular file " + localTarget);
    }

    SshClient sshClient = getSsh();
    Path remoteFile = Paths.get(remoteSrc);
    String remoteTarSrc = remoteFile.getParent() + "/" + remoteFile.getFileName() + ".tar"; // TODO: separators for other
                                                                                            // platforms?
    String command = "cd " + remoteFile.getParent().toString() + " ; tar " + "cf " + remoteTarSrc + " "
            + remoteFile.getFileName().toString();
    SunstoneCoreLogger.SSH.debug("Using command '{}' to tar remote file on node '{}'", command, getName());
    ExecResponse execResponse = sshClient.exec(command);
    if (execResponse.getExitStatus() != 0) {
        SunstoneCoreLogger.SSH.warn("Error output when copying file on node '{}': {}", getName(), execResponse.getError());
        throw new IllegalStateException("File cannot be copied successfully. Return code of remote tar archive creation is "
                + execResponse.getExitStatus());
    }

    Payload payload = sshClient.get(remoteTarSrc);

    try (TarInputStream tis = new TarInputStream(payload.openStream())) {
        if (remoteFileType == SshUtils.FileType.DIRECTORY) {
            SshUtils.untarFolder(tis, localTarget,
                    localFileType == SshUtils.FileType.NA ? new File(remoteSrc).getName() : null);
        } else {
            SshUtils.untarFile(tis, localTarget, localFileType == SshUtils.FileType.DIRECTORY);
        }

        while (tis.getNextEntry() != null) {
            // just skip
        }
    } catch (IOException e) {
        throw new RuntimeException(
                "Copying file " + remoteSrc + " from node " + getInitialNodeMetadata().getId() + " failed", e);
    } finally {
        exec("rm", remoteTarSrc); // TODO why not sshClient.exec(), like above for the 'tar' command?
        sshClient.disconnect();
        SunstoneCoreLogger.SSH.debug("Copied remote path '{}' on node '{}' to local target '{}'", remoteSrc, getName(),
                localTarget);
    }
}
 

import org.jclouds.compute.domain.ExecResponse; //导入依赖的package包/类
/**
 * @throws OperationNotSupportedException when connecting to SSH fails, presumably because there's no SSH server
 * @throws InterruptedException when interrupted while waiting for SSH to connect
 */
public JCloudsSshClient(AbstractJCloudsNode<?> node) throws OperationNotSupportedException, InterruptedException {

    org.jclouds.ssh.SshClient jcloudsSshClient = null;
    boolean connected = false;

    ExponentialBackoff backoff = new ExponentialBackoff(1000);
    long endTime = System.currentTimeMillis() + TimeUnit.MINUTES.toMillis(1);
    int count = 1;
    while (System.currentTimeMillis() < endTime) {
        NodeMetadata nodeMetadata = node.getFreshNodeMetadata();
        jcloudsSshClient = node.getCloudProvider().getComputeServiceContext().utils().sshForNode().apply(nodeMetadata);

        if (jcloudsSshClient != null) {
            try {
                jcloudsSshClient.connect();
                connected = true;
                break;
            } catch (Exception e) {
                SunstoneCoreLogger.SSH.debug("Failed to establish SSH connection to node '{}' (attempt {})", node.getName(),
                        count, e);

                try {
                    jcloudsSshClient.disconnect();
                } catch (Exception e2) {
                    SunstoneCoreLogger.SSH.trace("Failed to destroy SSH client that failed to connect", e2);
                }
            }
        }

        backoff.delay();

        count++;
    }

    if (jcloudsSshClient == null || !connected) {
        SunstoneCoreLogger.SSH.warn("Failed to establish SSH connection to node '{}'", node.getName());
        throw new OperationNotSupportedException("Failed to establish SSH connection to node '" + node.getName() + "'");
    }

    if (isSudoersFixRequired(node, jcloudsSshClient)) {
        // see https://bugzilla.redhat.com/show_bug.cgi?id=1020147
        LOGGER.trace("Removing 'Defaults requiretty' from /etc/sudoers so that sudo works without a PTY");
        ExecResponse result = jcloudsSshClient
                .exec("sudo -n sed -i -e 's/^Defaults[ ]\\+requiretty/#Defaults requiretty/' /etc/sudoers");
        if (result.getExitStatus() != 0) {
            LOGGER.warn("Failed removing 'Defaults requiretty' from /etc/sudoers, running with sudo might not work");
            LOGGER.debug("stdout: {}", result.getOutput());
            LOGGER.debug("stderr: {}", result.getError());
        }
    }

    this.jclouds = jcloudsSshClient;
}
 

import org.jclouds.compute.domain.ExecResponse; //导入依赖的package包/类
public ExecResponse startDaemonOnNode(InitScript daemon, String nodeId) {
   return compute.runScriptOnNode(nodeId, daemon, asCurrentUser().blockOnComplete(false));
}
 

import org.jclouds.compute.domain.ExecResponse; //导入依赖的package包/类
/** TODO: Move to CassandraService? */
protected void callOnHosts(List<InetAddress> hosts, String functionName, String... functionArgs)
{
    final Set<String> hostset = new HashSet<String>();

    for (InetAddress host : hosts)
        hostset.add(host.getHostAddress());

    StatementBuilder statementBuilder = new StatementBuilder();
    statementBuilder.addStatement(Statements.call(functionName, functionArgs));
    Credentials credentials = new Credentials(clusterSpec.getClusterUser(), clusterSpec.getPrivateKey());

    Map<? extends NodeMetadata,ExecResponse> results;
    try
    {
        results = computeService.runScriptOnNodesMatching(new Predicate<NodeMetadata>()
        {
            public boolean apply(NodeMetadata node)
            {
                Set<String> intersection = new HashSet<String>(hostset);
                intersection.retainAll(node.getPublicAddresses());
                return !intersection.isEmpty();
            }
        },
        statementBuilder,
        RunScriptOptions.Builder.overrideCredentialsWith(credentials).wrapInInitScript(false).runAsRoot(false));
    }
    catch (RunScriptOnNodesException e)
    {
        throw new RuntimeException(e);
    }

    if (results.size() != hostset.size())
    {
        throw new RuntimeException(results.size() + " hosts matched " + hostset + ": " + results);
    }

    for (ExecResponse response : results.values())
    {
        if (response.getExitCode() != 0)
        {
            throw new RuntimeException("Call " + functionName + " failed on at least one of " + hostset + ": " + results.values());
        }
    }
}
 

import org.jclouds.compute.domain.ExecResponse; //导入依赖的package包/类
/**
 * Runs a script on a node
 * @param nodeIndex node index
 * @param script the script to run
 * @return the result
 * @throws RunScriptOnNodesException
 */
public ExecResponse runScriptOnNode(int nodeIndex, String script) throws RunScriptOnNodesException {
	requireOpenState();
	
	NodeMetadata node = getNodeMetadata().asList().get(nodeIndex);
	return log(node, getComputeService().runScriptOnNode(node.getId(), script, getScriptLoginCredentials().runAsRoot(true).wrapInInitScript(false)));
}
 

import org.jclouds.compute.domain.ExecResponse; //导入依赖的package包/类
/**
 * Non-blocking script execution on a remote node
 * @param nodeIndex node index
 * @param script the script to run
 * @return a ListenableFuture object to access the result once the script is complete
 * @throws RunScriptOnNodesException
 */
public ListenableFuture<ExecResponse> submitScriptOnNode(int nodeIndex, String script) throws RunScriptOnNodesException {
	requireOpenState();
	
	NodeMetadata node = getNodeMetadata().asList().get(nodeIndex);
	return log(node, getComputeService().submitScriptOnNode(node.getId(), script, getScriptLoginCredentials().runAsRoot(true).wrapInInitScript(false)));
}
 

import org.jclouds.compute.domain.ExecResponse; //导入依赖的package包/类
/**
 * Runs a script on all nodes
 * @param script the script to run
 * @return the results from all nodes on which this script was run
 * @throws RunScriptOnNodesException
 */
public Map<? extends NodeMetadata, ExecResponse> runScriptOnAllNodes(String script) throws RunScriptOnNodesException {
	requireOpenState();
	
	return log(getComputeService().runScriptOnNodesMatching(getGroupPredicate(), script, getScriptLoginCredentials().runAsRoot(true).wrapInInitScript(false)));
}