Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ package org.apache.brooklyn.location.jclouds; import static org.apache.brooklyn.util.JavaGroovyEquivalents.groovyTruth; import java.util.List; import java.util.Map; import java.util.Set; import java.util.concurrent.ExecutionException; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; import javax.annotation.Nullable; import org.apache.brooklyn.api.location.HardwareDetails; import org.apache.brooklyn.api.location.MachineDetails; import org.apache.brooklyn.api.location.OsDetails; import org.apache.brooklyn.core.location.BasicHardwareDetails; import org.apache.brooklyn.core.location.BasicMachineDetails; import org.apache.brooklyn.core.location.BasicOsDetails; import org.apache.brooklyn.core.location.LocationConfigUtils; import org.apache.brooklyn.core.location.LocationConfigUtils.OsCredential; import org.apache.brooklyn.location.ssh.SshMachineLocation; import org.apache.brooklyn.util.core.flags.SetFromFlag; import org.apache.brooklyn.util.exceptions.Exceptions; import org.apache.brooklyn.util.net.Networking; import org.apache.brooklyn.util.text.Strings; import org.jclouds.compute.ComputeServiceContext; import org.jclouds.compute.callables.RunScriptOnNode; import org.jclouds.compute.domain.ExecResponse; import org.jclouds.compute.domain.Hardware; import org.jclouds.compute.domain.Image; import org.jclouds.compute.domain.NodeMetadata; import org.jclouds.compute.domain.OperatingSystem; import org.jclouds.compute.domain.OsFamily; import org.jclouds.compute.domain.Processor; import org.jclouds.compute.domain.Template; import org.jclouds.compute.options.RunScriptOptions; import org.jclouds.domain.LoginCredentials; import org.jclouds.scriptbuilder.domain.InterpretableStatement; import org.jclouds.scriptbuilder.domain.Statement; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.google.common.annotations.VisibleForTesting; import com.google.common.base.Objects; import com.google.common.base.Optional; import com.google.common.base.Throwables; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; import com.google.common.net.HostAndPort; import com.google.common.util.concurrent.ListenableFuture; public class JcloudsSshMachineLocation extends SshMachineLocation implements JcloudsMachineLocation { private static final Logger LOG = LoggerFactory.getLogger(JcloudsSshMachineLocation.class); @SetFromFlag JcloudsLocation jcloudsParent; /** * @deprecated since 0.9.0; the node should not be persisted. */ @SetFromFlag @Deprecated NodeMetadata node; /** * @deprecated since 0.9.0; the template should not be persisted. */ @SetFromFlag @Deprecated Template template; @SetFromFlag String nodeId; @SetFromFlag String imageId; @SetFromFlag Set<String> privateAddresses; @SetFromFlag Set<String> publicAddresses; @SetFromFlag String hostname; // Populated lazily, on first call to getSubnetHostname() @SetFromFlag String privateHostname; /** * Historically, "node" and "template" were persisted. However that is a very bad idea! * It means we pull in lots of jclouds classes into the persisted state. We are at an * intermediate stage, where we want to handle rebinding to old state that has "node" * and new state that should not. We therefore leave in the {@code @SetFromFlag} on node * so that we read it back, but we ensure the value is null when we write it out! * * TODO We will rename these to get rid of the ugly underscore when the old node/template * fields are deleted. */ private transient Optional<NodeMetadata> _node; private transient Optional<Template> _template; private transient Optional<Image> _image; private RunScriptOnNode.Factory runScriptFactory; public JcloudsSshMachineLocation() { } /** * @deprecated since 0.6; use LocationSpec (which calls no-arg constructor) */ @Deprecated public JcloudsSshMachineLocation(Map<?, ?> flags, JcloudsLocation jcloudsParent, NodeMetadata node) { super(flags); this.jcloudsParent = jcloudsParent; init(); } @Override public void init() { if (jcloudsParent != null) { super.init(); ComputeServiceContext context = jcloudsParent.getComputeService().getContext(); runScriptFactory = context.utils().injector().getInstance(RunScriptOnNode.Factory.class); if (node != null) { setNode(node); } if (template != null) { setTemplate(template); } } else { // TODO Need to fix the rebind-detection, and not call init() on rebind. // This will all change when locations become entities. if (LOG.isDebugEnabled()) LOG.debug("Not doing init() of {} because parent not set; presuming rebinding", this); } } @Override public void rebind() { super.rebind(); ComputeServiceContext context = jcloudsParent.getComputeService().getContext(); runScriptFactory = context.utils().injector().getInstance(RunScriptOnNode.Factory.class); if (node != null) { setNode(node); node = null; } if (template != null) { setTemplate(template); template = null; } } @Override public String toVerboseString() { return Objects.toStringHelper(this).omitNullValues().add("id", getId()).add("name", getDisplayName()) .add("user", getUser()).add("address", getAddress()).add("port", getConfig(SSH_PORT)) .add("node", _node).add("nodeId", getJcloudsId()).add("imageId", getImageId()) .add("privateAddresses", getPrivateAddresses()).add("publicAddresses", getPublicAddresses()) .add("parentLocation", getParent()).add("osDetails", getOptionalOsDetails()).toString(); } protected void setNode(NodeMetadata node) { this.node = null; nodeId = node.getId(); imageId = node.getImageId(); privateAddresses = node.getPrivateAddresses(); publicAddresses = node.getPublicAddresses(); hostname = node.getHostname(); _node = Optional.of(node); } protected void setTemplate(Template template) { this.template = null; _template = Optional.of(template); _image = Optional.fromNullable(template.getImage()); } @Override public Optional<NodeMetadata> getOptionalNode() { if (_node == null) { _node = Optional.fromNullable(getParent().getComputeService().getNodeMetadata(nodeId)); } return _node; } protected Optional<Image> getOptionalImage() { if (_image == null) { _image = Optional.fromNullable(getParent().getComputeService().getImage(imageId)); } return _image; } /** * @since 0.9.0 * @deprecated since 0.9.0 (only added as aid until the deprecated {@link #getTemplate()} is deleted) */ @Deprecated protected Optional<Template> getOptionalTemplate() { if (_template == null) { _template = Optional.absent(); } return _template; } /** * @deprecated since 0.9.0 */ @Override @Deprecated public NodeMetadata getNode() { Optional<NodeMetadata> result = getOptionalNode(); if (result.isPresent()) { return result.get(); } else { throw new IllegalStateException("Node " + nodeId + " not present in " + getParent()); } } @VisibleForTesting Optional<NodeMetadata> peekNode() { return _node; } /** * @deprecated since 0.9.0 */ @Override @Deprecated public Template getTemplate() { Optional<Template> result = getOptionalTemplate(); if (result.isPresent()) { String msg = "Deprecated use of getTemplate() for " + this; LOG.warn(msg + " - see debug log for stacktrace"); LOG.debug(msg, new Exception("for stacktrace")); return result.get(); } else { throw new IllegalStateException("Template for " + nodeId + " (in " + getParent() + ") not cached (deprecated use of getTemplate())"); } } @Override public JcloudsLocation getParent() { return jcloudsParent; } @Override public String getHostname() { // Changed behaviour in Brooklyn 0.9.0. Previously it just did node.getHostname(), which // was wrong on some clouds (e.g. vcloud-director, where VMs are often given a random // hostname that does not resolve on the VM and is not in any DNS). // Now delegates to jcloudsParent.getPublicHostname(node). if (privateHostname == null) { Optional<NodeMetadata> node = getOptionalNode(); if (node.isPresent()) { HostAndPort sshHostAndPort = getSshHostAndPort(); LoginCredentials creds = getLoginCredentials(); hostname = jcloudsParent.getPublicHostname(node.get(), Optional.of(sshHostAndPort), creds, config().getBag()); requestPersist(); } else { // Fallback: impl taken (mostly) from jcloudsParent.getPublicHostnameGeneric(NodeMetadata, ConfigBag). // But we won't have a node object (e.g. after rebind, and VM has been terminated). // We also resort to address.getHostAddress as final fallback. if (groovyTruth(getPublicAddresses())) { hostname = getPublicAddresses().iterator().next(); } else if (groovyTruth(getPrivateAddresses())) { hostname = getPrivateAddresses().iterator().next(); } else { hostname = getAddress().getHostAddress(); } } LOG.debug("Resolved hostname {} for {}", hostname, this); requestPersist(); } return hostname; } /** In clouds like AWS, the public hostname is the only way to ensure VMs in different zones can access each other. */ @Override public Set<String> getPublicAddresses() { return (publicAddresses == null) ? ImmutableSet.<String>of() : publicAddresses; } @Override public Set<String> getPrivateAddresses() { return (privateAddresses == null) ? ImmutableSet.<String>of() : privateAddresses; } @Override public String getSubnetHostname() { if (privateHostname == null) { Optional<NodeMetadata> node = getOptionalNode(); if (node.isPresent()) { // Prefer jcloudsLocation.getPrivateHostname(): it handles AWS hostname in a special way, // by querying AWS for the hostname that resolves both inside and outside of the region. // If we can't get the node (i.e. the cloud provider doesn't know that id, because it has // been terminated), then we don't care as much about getting the right id! HostAndPort sshHostAndPort = getSshHostAndPort(); LoginCredentials creds = getLoginCredentials(); privateHostname = jcloudsParent.getPrivateHostname(node.get(), Optional.of(sshHostAndPort), creds, config().getBag()); } else { // Fallback: impl taken from jcloudsParent.getPrivateHostnameGeneric(NodeMetadata, ConfigBag). // But we won't have a node object (e.g. after rebind, and VM has been terminated). //prefer the private address to the hostname because hostname is sometimes wrong/abbreviated //(see that javadoc; also e.g. on rackspace/cloudstack, the hostname is not registered with any DNS). //Don't return local-only address (e.g. never 127.0.0.1) for (String p : getPrivateAddresses()) { if (Networking.isLocalOnly(p)) continue; privateHostname = p; break; } if (Strings.isBlank(privateHostname) && groovyTruth(getPublicAddresses())) { privateHostname = getPublicAddresses().iterator().next(); } else if (Strings.isBlank(privateHostname)) { privateHostname = getHostname(); } } requestPersist(); LOG.debug("Resolved subnet hostname {} for {}", privateHostname, this); } return privateHostname; } @Override public String getSubnetIp() { // Previous to Brooklyn 0.9.0, this could return the hostname or would try to do // jcloudsParent.getPublicHostname, and return the resolved IP. That was clearly // not a "subnet ip"! Optional<String> privateAddress = getPrivateAddress(); if (privateAddress.isPresent()) { return privateAddress.get(); } if (groovyTruth(node.getPublicAddresses())) { return node.getPublicAddresses().iterator().next(); } return null; } protected Optional<String> getPrivateAddress() { for (String p : getPrivateAddresses()) { // disallow local only addresses if (Networking.isLocalOnly(p)) continue; // other things may be public or private, but either way, return it return Optional.of(p); } return Optional.absent(); } @Override public String getJcloudsId() { return nodeId; } protected String getImageId() { return imageId; } /** executes the given statements on the server using jclouds ScriptBuilder, * wrapping in a script which is polled periodically. * the output is returned once the script completes (disadvantage compared to other methods) * but the process is nohupped and the SSH session is not kept, * so very useful for long-running processes * * @deprecated since 0.9.0; use standard {@link #execScript(String, List)} and the other variants. */ @Deprecated public ListenableFuture<ExecResponse> submitRunScript(String... statements) { return submitRunScript(new InterpretableStatement(statements)); } /** * @deprecated since 0.9.0; use standard {@link #execScript(String, List)} and the other variants. */ @Deprecated public ListenableFuture<ExecResponse> submitRunScript(Statement script) { return submitRunScript(script, new RunScriptOptions()); } /** * @deprecated since 0.9.0; use standard {@link #execScript(String, List)} and the other variants. */ @Deprecated public ListenableFuture<ExecResponse> submitRunScript(Statement script, RunScriptOptions options) { Optional<NodeMetadata> node = getOptionalNode(); if (node.isPresent()) { return runScriptFactory.submit(node.get(), script, options); } else { throw new IllegalStateException("Node " + nodeId + " not present in " + getParent()); } } /** * Uses submitRunScript to execute the commands, and throws error if it fails or returns non-zero * * @deprecated since 0.9.0; use standard {@link #execScript(String, List)} and the other variants. */ @Deprecated public void execRemoteScript(String... commands) { try { ExecResponse result = submitRunScript(commands).get(); if (result.getExitStatus() != 0) throw new IllegalStateException( "Error running remote commands (code " + result.getExitStatus() + "): " + commands); } catch (InterruptedException e) { Thread.currentThread().interrupt(); throw Throwables.propagate(e); } catch (ExecutionException e) { throw Throwables.propagate(e); } } /** * Retrieves the password for this VM, if one exists. The behaviour/implementation is different for different clouds. * e.g. on Rackspace, the password for a windows VM is available immediately; on AWS-EC2, for a Windows VM you need * to poll repeatedly until the password is available which can take up to 15 minutes. * * @deprecated since 0.9.0; use the machine to execute commands, so no need to extract the password */ @Deprecated public String waitForPassword() { Optional<NodeMetadata> node = getOptionalNode(); if (node.isPresent()) { // TODO Hacky; don't want aws specific stuff here but what to do?! if (jcloudsParent.getProvider().equals("aws-ec2")) { try { return JcloudsUtil.waitForPasswordOnAws(jcloudsParent.getComputeService(), node.get(), 15, TimeUnit.MINUTES); } catch (TimeoutException e) { throw Throwables.propagate(e); } } else { LoginCredentials credentials = node.get().getCredentials(); return (credentials != null) ? credentials.getOptionalPassword().orNull() : null; } } else { throw new IllegalStateException("Node " + nodeId + " not present in " + getParent()); } } private LoginCredentials getLoginCredentials() { OsCredential creds = LocationConfigUtils.getOsCredential(config().getBag()); return LoginCredentials.builder().user(getUser()) .privateKey(creds.hasKey() ? creds.getPrivateKeyData() : null) .password(creds.hasPassword() ? creds.getPassword() : null).build(); } /** * Returns the known OsDetails, without any attempt to retrieve them if not known. */ protected Optional<OsDetails> getOptionalOsDetails() { Optional<MachineDetails> machineDetails = getOptionalMachineDetails(); OsDetails result = machineDetails.isPresent() ? machineDetails.get().getOsDetails() : null; return Optional.fromNullable(result); } protected Optional<OperatingSystem> getOptionalOperatingSystem() { Optional<NodeMetadata> node = getOptionalNode(); OperatingSystem os = node.isPresent() ? node.get().getOperatingSystem() : null; if (os == null) { // some nodes (eg cloudstack, gce) might not get OS available on the node, // so also try taking it from the image if available Optional<Image> image = getOptionalImage(); if (image.isPresent()) { os = image.get().getOperatingSystem(); } } return Optional.fromNullable(os); } protected Optional<Hardware> getOptionalHardware() { Optional<NodeMetadata> node = getOptionalNode(); return Optional.fromNullable(node.isPresent() ? node.get().getHardware() : null); } @Override protected MachineDetails inferMachineDetails() { Optional<String> name = Optional.absent(); Optional<String> version = Optional.absent(); Optional<String> architecture = Optional.absent(); Optional<OperatingSystem> os = getOptionalOperatingSystem(); Optional<Hardware> hardware = getOptionalHardware(); if (os.isPresent()) { // Note using family rather than name. Name is often unset. // Using is64Bit rather then getArch because getArch often returns "paravirtual" OsFamily family = os.get().getFamily(); String versionRaw = os.get().getVersion(); boolean is64Bit = os.get().is64Bit(); name = Optional.fromNullable( family != null && !OsFamily.UNRECOGNIZED.equals(family) ? family.toString() : null); version = Optional.fromNullable(Strings.isNonBlank(versionRaw) ? versionRaw : null); architecture = Optional .fromNullable(is64Bit ? BasicOsDetails.OsArchs.X_86_64 : BasicOsDetails.OsArchs.I386); } Optional<Integer> ram = hardware.isPresent() ? Optional.fromNullable(hardware.get().getRam()) : Optional.<Integer>absent(); Optional<Integer> cpus = hardware.isPresent() ? Optional.fromNullable( hardware.get().getProcessors() != null ? hardware.get().getProcessors().size() : null) : Optional.<Integer>absent(); // Skip superclass' SSH to machine if all data is present, otherwise defer to super if (name.isPresent() && version.isPresent() && architecture.isPresent() && ram.isPresent() && cpus.isPresent()) { if (LOG.isTraceEnabled()) { LOG.trace("Gathered machine details from Jclouds, skipping SSH test on {}", this); } OsDetails osD = new BasicOsDetails(name.get(), architecture.get(), version.get()); HardwareDetails hwD = new BasicHardwareDetails(cpus.get(), ram.get()); return new BasicMachineDetails(hwD, osD); } else if ("false".equalsIgnoreCase(getConfig(JcloudsLocation.WAIT_FOR_SSHABLE))) { if (LOG.isTraceEnabled()) { LOG.trace( "Machine details for {} missing from Jclouds, but skipping SSH test because waitForSshable=false. name={}, version={}, " + "arch={}, ram={}, #cpus={}", new Object[] { this, name, version, architecture, ram, cpus }); } OsDetails osD = new BasicOsDetails(name.orNull(), architecture.orNull(), version.orNull()); HardwareDetails hwD = new BasicHardwareDetails(cpus.orNull(), ram.orNull()); return new BasicMachineDetails(hwD, osD); } else { if (LOG.isTraceEnabled()) { LOG.trace( "Machine details for {} missing from Jclouds, using SSH test instead. name={}, version={}, " + "arch={}, ram={}, #cpus={}", new Object[] { this, name, version, architecture, ram, cpus }); } return super.inferMachineDetails(); } } @Override public Map<String, String> toMetadataRecord() { Optional<NodeMetadata> node = getOptionalNode(); Optional<Hardware> hardware = getOptionalHardware(); List<? extends Processor> processors = hardware.isPresent() ? hardware.get().getProcessors() : null; ImmutableMap.Builder<String, String> builder = ImmutableMap.builder(); builder.putAll(super.toMetadataRecord()); putIfNotNull(builder, "provider", getParent().getProvider()); putIfNotNull(builder, "account", getParent().getIdentity()); putIfNotNull(builder, "region", getParent().getRegion()); putIfNotNull(builder, "serverId", getJcloudsId()); putIfNotNull(builder, "imageId", getImageId()); putIfNotNull(builder, "instanceTypeName", (hardware.isPresent() ? hardware.get().getName() : null)); putIfNotNull(builder, "instanceTypeId", (hardware.isPresent() ? hardware.get().getProviderId() : null)); putIfNotNull(builder, "ram", "" + (hardware.isPresent() ? hardware.get().getRam() : null)); putIfNotNull(builder, "cpus", "" + (processors != null ? processors.size() : null)); try { OsDetails osDetails = getOsDetails(); putIfNotNull(builder, "osName", osDetails.getName()); putIfNotNull(builder, "osArch", osDetails.getArch()); putIfNotNull(builder, "is64bit", osDetails.is64bit() ? "true" : "false"); } catch (Exception e) { Exceptions.propagateIfFatal(e); LOG.warn("Unable to get OS Details for " + node + "; continuing", e); } return builder.build(); } private void putIfNotNull(ImmutableMap.Builder<String, String> builder, String key, @Nullable String value) { if (value != null) builder.put(key, value); } }