Repository: incubator-brooklyn Updated Branches: refs/heads/master d64808206 -> 8880bcd00
temporary local copy of fix for HVM/paravirtual issue on AWS fixes https://issues.apache.org/jira/browse/BROOKLYN-140 as noted, when new jclouds lands we should revert this Project: http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/repo Commit: http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/commit/31b29b30 Tree: http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/tree/31b29b30 Diff: http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/diff/31b29b30 Branch: refs/heads/master Commit: 31b29b305ae366edf590912c5dbae57f6dbcc16e Parents: 7b97cee Author: Alex Heneveld <[email protected]> Authored: Wed Apr 22 13:57:56 2015 +0100 Committer: Alex Heneveld <[email protected]> Committed: Wed Apr 22 14:03:36 2015 +0100 ---------------------------------------------------------------------- .../ec2/compute/domain/EC2HardwareBuilder.java | 860 +++++++++++++++++++ 1 file changed, 860 insertions(+) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/31b29b30/locations/jclouds/src/main/java/org/jclouds/ec2/compute/domain/EC2HardwareBuilder.java ---------------------------------------------------------------------- diff --git a/locations/jclouds/src/main/java/org/jclouds/ec2/compute/domain/EC2HardwareBuilder.java b/locations/jclouds/src/main/java/org/jclouds/ec2/compute/domain/EC2HardwareBuilder.java new file mode 100644 index 0000000..b6f1c11 --- /dev/null +++ b/locations/jclouds/src/main/java/org/jclouds/ec2/compute/domain/EC2HardwareBuilder.java @@ -0,0 +1,860 @@ +/* + * 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.jclouds.ec2.compute.domain; + +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.base.Predicates.not; +import static org.jclouds.compute.domain.Volume.Type.LOCAL; +import static org.jclouds.compute.predicates.ImagePredicates.any; +import static org.jclouds.compute.predicates.ImagePredicates.idIn; + +import java.net.URI; +import java.util.List; +import java.util.Map; + +import org.jclouds.compute.domain.Hardware; +import org.jclouds.compute.domain.HardwareBuilder; +import org.jclouds.compute.domain.Image; +import org.jclouds.compute.domain.Processor; +import org.jclouds.compute.domain.Volume; +import org.jclouds.compute.domain.VolumeBuilder; +import org.jclouds.compute.predicates.ImagePredicates; +import org.jclouds.domain.Location; +import org.jclouds.ec2.domain.InstanceType; +import org.jclouds.ec2.domain.RootDeviceType; +import org.jclouds.ec2.domain.VirtualizationType; + +import com.google.common.base.Preconditions; +import com.google.common.base.Predicate; +import com.google.common.base.Predicates; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableList.Builder; +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Lists; + +/** + * BROOKLYN-SPECIFIC: + * TODO remove when we use jclouds cut which includes this. + * This is a copy of fixes for HVM/Paravirtual bug against AWS introduced in the first commit at + * https://github.com/jclouds/jclouds/pull/732. + * The Brooklyn bug is https://issues.apache.org/jira/browse/BROOKLYN-140. + * (Apart from these lines, the code is identical.) + * + * @see <a href= + * "http://docs.amazonwebservices.com/AWSEC2/latest/UserGuide/index.html?instance-types.html"; + * /> + * + * and <a href= + * "http://aws.amazon.com/amazon-linux-ami/instance-type-matrix/"; + * />. + * + * Also note Windows only supports HVM, as per + * <a href= + * "http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/virtualization_types.html"; + * />. + * On Windows you may have to constrain hardware appropriately. + */ +public class EC2HardwareBuilder extends HardwareBuilder { + private Predicate<Image> rootDeviceType = any(); + private Predicate<Image> virtualizationType = null; + private Predicate<Image> imageIds = any(); + private Predicate<Image> is64Bit = any(); + + public EC2HardwareBuilder() { + this.supportsImage = null; + } + + /** + * evaluates true if the Image has the following rootDeviceType + * + * @param type + * rootDeviceType of the image + * @return predicate + */ + public static class RequiresRootDeviceType implements Predicate<Image> { + final RootDeviceType type; + + public RequiresRootDeviceType(final RootDeviceType type) { + this.type = checkNotNull(type, "type must be defined"); + } + + @Override + public boolean apply(Image image) { + return image.getUserMetadata().containsKey("rootDeviceType") + && type == RootDeviceType.fromValue(image.getUserMetadata().get("rootDeviceType")); + } + + @Override + public String toString() { + return "requiresRootDeviceType(" + type + ")"; + } + + } + + /** + * evaluates true if the Image requires the following virtualizationType + * + * @param type + * virtualizationType of the image + * @return predicate + */ + public static class RequiresVirtualizationType implements Predicate<Image> { + final VirtualizationType type; + + public RequiresVirtualizationType(final VirtualizationType type) { + this.type = checkNotNull(type, "type must be defined"); + } + + @Override + public boolean apply(Image image) { + return image.getOperatingSystem() != null && image.getOperatingSystem().getArch() != null + && type == VirtualizationType.fromValue(image.getOperatingSystem().getArch()); + } + + @Override + public String toString() { + return "requiresVirtualizationType(" + type + ")"; + } + + } + + public EC2HardwareBuilder(String instanceType) { + ids(instanceType); + } + + public EC2HardwareBuilder virtualizationType(VirtualizationType virtualizationType) { + this.virtualizationType = new RequiresVirtualizationType(virtualizationType); + return this; + } + + public EC2HardwareBuilder virtualizationTypes(VirtualizationType ...virtualizationTypes) { + Preconditions.checkArgument(virtualizationTypes.length > 0, "At least one virtualization type is required."); + if (virtualizationTypes.length == 1) { + this.virtualizationType = new RequiresVirtualizationType(virtualizationTypes[0]); + } else { + List<RequiresVirtualizationType> supportedVirtualizationTypes = Lists.newArrayList(); + for (VirtualizationType virtualizationType : virtualizationTypes) { + supportedVirtualizationTypes.add(new RequiresVirtualizationType(virtualizationType)); + } + this.virtualizationType = Predicates.or(supportedVirtualizationTypes); + } + return this; + } + + public EC2HardwareBuilder rootDeviceType(RootDeviceType rootDeviceType) { + this.rootDeviceType = new RequiresRootDeviceType(rootDeviceType); + return this; + } + + public EC2HardwareBuilder supportsImageIds(Iterable<String> ids) { + this.imageIds = idIn(ids); + return this; + } + + public EC2HardwareBuilder ids(String id) { + return EC2HardwareBuilder.class.cast(super.ids(id)); + } + + public EC2HardwareBuilder ram(int ram) { + return EC2HardwareBuilder.class.cast(super.ram(ram)); + } + + public EC2HardwareBuilder processors(List<Processor> processors) { + return EC2HardwareBuilder.class.cast(super.processors(processors)); + } + + public EC2HardwareBuilder volumes(List<Volume> volumes) { + return EC2HardwareBuilder.class.cast(super.volumes(volumes)); + } + + public EC2HardwareBuilder supportsImage(Predicate<Image> supportsImage) { + return EC2HardwareBuilder.class.cast(super.supportsImage(supportsImage)); + } + + public EC2HardwareBuilder is64Bit(boolean is64Bit) { + this.is64Bit = is64Bit ? ImagePredicates.is64Bit() : not(ImagePredicates.is64Bit()); + return this; + } + + public EC2HardwareBuilder id(String id) { + return EC2HardwareBuilder.class.cast(super.id(id)); + } + + @Override + public EC2HardwareBuilder providerId(String providerId) { + return EC2HardwareBuilder.class.cast(super.providerId(providerId)); + } + + @Override + public EC2HardwareBuilder name(String name) { + return EC2HardwareBuilder.class.cast(super.name(name)); + } + + @Override + public EC2HardwareBuilder location(Location location) { + return EC2HardwareBuilder.class.cast(super.location(location)); + } + + @Override + public EC2HardwareBuilder uri(URI uri) { + return EC2HardwareBuilder.class.cast(super.uri(uri)); + } + + @Override + public EC2HardwareBuilder userMetadata(Map<String, String> userMetadata) { + return EC2HardwareBuilder.class.cast(super.userMetadata(userMetadata)); + } + + private EC2HardwareBuilder t2() { + virtualizationTypes(VirtualizationType.HVM); + return this; + } + + private EC2HardwareBuilder m3() { + virtualizationTypes(VirtualizationType.HVM, VirtualizationType.PARAVIRTUAL); + return this; + } + + private EC2HardwareBuilder c3() { + virtualizationTypes(VirtualizationType.HVM, VirtualizationType.PARAVIRTUAL); + return this; + } + + private EC2HardwareBuilder c4() { + virtualizationTypes(VirtualizationType.HVM, VirtualizationType.PARAVIRTUAL); + return this; + } + + // TODO include D2 (dense) types? + @SuppressWarnings("unused") + private EC2HardwareBuilder d2() { + virtualizationTypes(VirtualizationType.HVM); + return this; + } + + private EC2HardwareBuilder r3() { + virtualizationTypes(VirtualizationType.HVM); + return this; + } + + private EC2HardwareBuilder g2() { + virtualizationTypes(VirtualizationType.HVM); + return this; + } + + private EC2HardwareBuilder i2() { + virtualizationTypes(VirtualizationType.HVM); + return this; + } + + private EC2HardwareBuilder hs1() { + virtualizationTypes(VirtualizationType.HVM, VirtualizationType.PARAVIRTUAL); + return this; + } + + // TODO below this line are previous generation, discouraged + // http://aws.amazon.com/ec2/previous-generation/ + private EC2HardwareBuilder m1() { + virtualizationTypes(VirtualizationType.PARAVIRTUAL); + return this; + } + + private EC2HardwareBuilder c1() { + virtualizationTypes(VirtualizationType.PARAVIRTUAL); + return this; + } + + private EC2HardwareBuilder cc2() { + virtualizationTypes(VirtualizationType.HVM); + return this; + } + + private EC2HardwareBuilder m2() { + virtualizationTypes(VirtualizationType.PARAVIRTUAL); + return this; + } + + // cr1 never included in jclouds, so skipped here + + private EC2HardwareBuilder hi1() { + virtualizationTypes(VirtualizationType.HVM, VirtualizationType.PARAVIRTUAL); + return this; + } + + private EC2HardwareBuilder t1() { + virtualizationTypes(VirtualizationType.PARAVIRTUAL); + return this; + } + + private EC2HardwareBuilder cg1() { + virtualizationTypes(VirtualizationType.HVM); + return this; + } + + private EC2HardwareBuilder cc1() { + // often no longer available - not adding capacity (use cc2) + virtualizationTypes(VirtualizationType.HVM); + return this; + } + + + /** + * @see InstanceType#M1_SMALL + */ + public static EC2HardwareBuilder m1_small() { + return new EC2HardwareBuilder(InstanceType.M1_SMALL).m1() + .ram(1740) + .processors(ImmutableList.of(new Processor(1.0, 1.0))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(150.0f).device("/dev/sda2").bootDevice(false).durable(false).build())); + } + + /** + * @see InstanceType#M1_MEDIUM + */ + public static EC2HardwareBuilder m1_medium() { + return new EC2HardwareBuilder(InstanceType.M1_MEDIUM).m1() + .ram(3750) + .processors(ImmutableList.of(new Processor(1.0, 2.0))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(420.0f).device("/dev/sdb").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(420.0f).device("/dev/sdc").bootDevice(false).durable(false).build())); + } + + + /** + * @see InstanceType#T1_MICRO + */ + public static EC2HardwareBuilder t1_micro() { + return new EC2HardwareBuilder(InstanceType.T1_MICRO).t1() + .ram(630) + .processors(ImmutableList.of(new Processor(1.0, 1.0))).rootDeviceType(RootDeviceType.EBS); + } + + /** + * @see InstanceType#T2_MICRO + */ + public static EC2HardwareBuilder t2_micro() { + return new EC2HardwareBuilder(InstanceType.T2_MICRO).t2() + .ram(1024) + .processors(ImmutableList.of(new Processor(1.0, 0.1))).rootDeviceType(RootDeviceType.EBS); + } + + /** + * @see InstanceType#T2_SMALL + */ + public static EC2HardwareBuilder t2_small() { + return new EC2HardwareBuilder(InstanceType.T2_SMALL).t2() + .ram(2048) + .processors(ImmutableList.of(new Processor(1.0, 0.2))).rootDeviceType(RootDeviceType.EBS); + } + + /** + * @see InstanceType#T2_MEDIUM + */ + public static EC2HardwareBuilder t2_medium() { + return new EC2HardwareBuilder(InstanceType.T2_MEDIUM).t2() + .ram(4096) + .processors(ImmutableList.of(new Processor(1.0, 0.4))).rootDeviceType(RootDeviceType.EBS); + } + + /** + * @see InstanceType#M1_LARGE + */ + public static EC2HardwareBuilder m1_large() { + return new EC2HardwareBuilder(InstanceType.M1_LARGE).m1() + .ram(7680) + .processors(ImmutableList.of(new Processor(2.0, 2.0))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(420.0f).device("/dev/sdb").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(420.0f).device("/dev/sdc").bootDevice(false).durable(false).build())) + .is64Bit(true); + } + + /** + * @see InstanceType#M1_XLARGE + */ + public static EC2HardwareBuilder m1_xlarge() { + return new EC2HardwareBuilder(InstanceType.M1_XLARGE).m1() + .ram(15360) + .processors(ImmutableList.of(new Processor(4.0, 2.0))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(420.0f).device("/dev/sdb").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(420.0f).device("/dev/sdc").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(420.0f).device("/dev/sdd").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(420.0f).device("/dev/sde").bootDevice(false).durable(false).build())) + .is64Bit(true); + } + + /** + * @see InstanceType#M2_XLARGE + */ + public static EC2HardwareBuilder m2_xlarge() { + return new EC2HardwareBuilder(InstanceType.M2_XLARGE).m2() + .ram(17510) + .processors(ImmutableList.of(new Processor(2.0, 3.25))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(420.0f).device("/dev/sda1").bootDevice(true).durable(false).build())) + .is64Bit(true); + } + + /** + * @see InstanceType#M2_2XLARGE + */ + public static EC2HardwareBuilder m2_2xlarge() { + return new EC2HardwareBuilder(InstanceType.M2_2XLARGE).m2() + .ram(35020) + .processors(ImmutableList.of(new Processor(4.0, 3.25))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(840.0f).device("/dev/sdb").bootDevice(false).durable(false).build())) + .is64Bit(true); + } + + /** + * @see InstanceType#M2_4XLARGE + */ + public static EC2HardwareBuilder m2_4xlarge() { + return new EC2HardwareBuilder(InstanceType.M2_4XLARGE).m2() + .ram(70041) + .processors(ImmutableList.of(new Processor(8.0, 3.25))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(840.0f).device("/dev/sdb").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(840.0f).device("/dev/sdc").bootDevice(false).durable(false).build())) + .is64Bit(true); + } + + /** + * @see InstanceType#M3_MEDIUM + */ + public static EC2HardwareBuilder m3_medium() { + return new EC2HardwareBuilder(InstanceType.M3_MEDIUM).m3() + .ram(3840) + .processors(ImmutableList.of(new Processor(1.0, 3.0))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(4.0f).device("/dev/sdb").bootDevice(false).durable(false).build())); + } + + /** + * @see InstanceType#M3_LARGE + */ + public static EC2HardwareBuilder m3_large() { + return new EC2HardwareBuilder(InstanceType.M3_LARGE).m3() + .ram(7680) + .processors(ImmutableList.of(new Processor(2.0, 3.25))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(32.0f).device("/dev/sdb").bootDevice(false).durable(false).build())); + } + + /** + * @see InstanceType#M3_XLARGE + */ + public static EC2HardwareBuilder m3_xlarge() { + return new EC2HardwareBuilder(InstanceType.M3_XLARGE).m3() + .ram(15360) + .processors(ImmutableList.of(new Processor(4.0, 3.25))) + .is64Bit(true) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(40.0f).device("/dev/sdb").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(40.0f).device("/dev/sdc").bootDevice(false).durable(false).build())); + } + + /** + * @see InstanceType#M3_2XLARGE + */ + public static EC2HardwareBuilder m3_2xlarge() { + return new EC2HardwareBuilder(InstanceType.M3_2XLARGE).m3() + .ram(30720) + .processors(ImmutableList.of(new Processor(8.0, 3.25))) + .is64Bit(true) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(80.0f).device("/dev/sdb").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(80.0f).device("/dev/sdc").bootDevice(false).durable(false).build())); + } + + /** + * @see InstanceType#C1_MEDIUM + */ + public static EC2HardwareBuilder c1_medium() { + return new EC2HardwareBuilder(InstanceType.C1_MEDIUM).c1() + .ram(1740) + .processors(ImmutableList.of(new Processor(2.0, 2.5))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(340.0f).device("/dev/sda2").bootDevice(false).durable(false).build())); + } + + /** + * @see InstanceType#C1_XLARGE + */ + public static EC2HardwareBuilder c1_xlarge() { + return new EC2HardwareBuilder(InstanceType.C1_XLARGE).c1() + .ram(7168) + .processors(ImmutableList.of(new Processor(8.0, 2.5))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(420.0f).device("/dev/sdb").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(420.0f).device("/dev/sdc").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(420.0f).device("/dev/sdd").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(420.0f).device("/dev/sde").bootDevice(false).durable(false).build())) + .is64Bit(true); + } + + /** + * @see InstanceType#C3_LARGE + */ + public static EC2HardwareBuilder c3_large() { + return new EC2HardwareBuilder(InstanceType.C3_LARGE).c3() + .ram(3750) + .processors(ImmutableList.of(new Processor(2.0, 3.5))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(16.0f).device("/dev/sdb").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(16.0f).device("/dev/sdc").bootDevice(false).durable(false).build())) + .is64Bit(true); + } + + /** + * @see InstanceType#C3_XLARGE + */ + public static EC2HardwareBuilder c3_xlarge() { + return new EC2HardwareBuilder(InstanceType.C3_XLARGE).c3() + .ram(7168) + .processors(ImmutableList.of(new Processor(4.0, 3.5))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(40.0f).device("/dev/sdb").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(40.0f).device("/dev/sdc").bootDevice(false).durable(false).build())) + .is64Bit(true); + } + + /** + * @see InstanceType#C3_2XLARGE + */ + public static EC2HardwareBuilder c3_2xlarge() { + return new EC2HardwareBuilder(InstanceType.C3_2XLARGE).c3() + .ram(15360) + .processors(ImmutableList.of(new Processor(8.0, 3.5))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(80.0f).device("/dev/sdb").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(80.0f).device("/dev/sdc").bootDevice(false).durable(false).build())) + .is64Bit(true); + } + + /** + * @see InstanceType#C3_4XLARGE + */ + public static EC2HardwareBuilder c3_4xlarge() { + return new EC2HardwareBuilder(InstanceType.C3_4XLARGE).c3() + .ram(30720) + .processors(ImmutableList.of(new Processor(16.0, 3.4375))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(160.0f).device("/dev/sdb").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(160.0f).device("/dev/sdc").bootDevice(false).durable(false).build())) + .is64Bit(true); + } + + /** + * @see InstanceType#C3_8XLARGE + */ + public static EC2HardwareBuilder c3_8xlarge() { + return new EC2HardwareBuilder(InstanceType.C3_8XLARGE).c3() + .ram(61440) + .processors(ImmutableList.of(new Processor(32.0, 3.375))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(320.0f).device("/dev/sdb").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(320.0f).device("/dev/sdc").bootDevice(false).durable(false).build())) + .is64Bit(true); + } + + /** + * @see InstanceType#C4_LARGE + */ + public static EC2HardwareBuilder c4_large() { + return new EC2HardwareBuilder(InstanceType.C4_LARGE).c4() + .ram(3840) + .processors(ImmutableList.of(new Processor(2.0, 3.5))) + .rootDeviceType(RootDeviceType.EBS); + } + + /** + * @see InstanceType#C4_XLARGE + */ + public static EC2HardwareBuilder c4_xlarge() { + return new EC2HardwareBuilder(InstanceType.C4_XLARGE).c4() + .ram(7680) + .processors(ImmutableList.of(new Processor(4.0, 3.5))) + .rootDeviceType(RootDeviceType.EBS); + } + + /** + * @see InstanceType#C4_2XLARGE + */ + public static EC2HardwareBuilder c4_2xlarge() { + return new EC2HardwareBuilder(InstanceType.C4_2XLARGE).c4() + .ram(15360) + .processors(ImmutableList.of(new Processor(8.0, 3.5))) + .rootDeviceType(RootDeviceType.EBS); + } + + /** + * @see InstanceType#C4_4XLARGE + */ + public static EC2HardwareBuilder c4_4xlarge() { + return new EC2HardwareBuilder(InstanceType.C4_4XLARGE).c4() + .ram(30720) + .processors(ImmutableList.of(new Processor(16.0, 3.5))) + .rootDeviceType(RootDeviceType.EBS); + } + + /** + * @see InstanceType#C4_8XLARGE + */ + public static EC2HardwareBuilder c4_8xlarge() { + return new EC2HardwareBuilder(InstanceType.C4_8XLARGE).c4() + .ram(61440) + .processors(ImmutableList.of(new Processor(36.0, 3.5))) + .rootDeviceType(RootDeviceType.EBS); + } + + public static EC2HardwareBuilder cg1_4xlarge() { + return new EC2HardwareBuilder(InstanceType.CG1_4XLARGE).cg1() + .ram(22 * 1024) + .processors(ImmutableList.of(new Processor(4.0, 4.0), new Processor(4.0, 4.0))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(840.0f).device("/dev/sdb").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(840.0f).device("/dev/sdc").bootDevice(false).durable(false).build())) + .virtualizationType(VirtualizationType.HVM); + } + + public static EC2HardwareBuilder cc1_4xlarge() { + return new EC2HardwareBuilder(InstanceType.CC1_4XLARGE).cc1() + .ram(23 * 1024) + .processors(ImmutableList.of(new Processor(4.0, 4.0), new Processor(4.0, 4.0))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(840.0f).device("/dev/sdb").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(840.0f).device("/dev/sdc").bootDevice(false).durable(false).build())) + .virtualizationType(VirtualizationType.HVM); + } + + public static EC2HardwareBuilder cc2_8xlarge() { + return new EC2HardwareBuilder(InstanceType.CC2_8XLARGE).cc2() + .ram(60 * 1024 + 512) + .processors(ImmutableList.of(new Processor(8.0, 5.5), new Processor(8.0, 5.5))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(840.0f).device("/dev/sdb").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(840.0f).device("/dev/sdc").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(840.0f).device("/dev/sdd").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(840.0f).device("/dev/sde").bootDevice(false).durable(false).build())) + .virtualizationType(VirtualizationType.HVM); + } + + /** + * @see InstanceType#G2_2XLARGE + */ + public static EC2HardwareBuilder g2_2xlarge() { + return new EC2HardwareBuilder(InstanceType.G2_2XLARGE).g2() + .ram(15 * 1024) + .processors(ImmutableList.of(new Processor(8.0, 3.25))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(60.0f).device("/dev/sdb").bootDevice(false).durable(false).build())) + .virtualizationType(VirtualizationType.HVM); + } + + /** + * @see InstanceType#I2_XLARGE + */ + public static EC2HardwareBuilder i2_xlarge() { + return new EC2HardwareBuilder(InstanceType.I2_XLARGE).i2() + .ram(30 * 1024 + 512) + .processors(ImmutableList.of(new Processor(4.0, 3.5))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(800.0f).device("/dev/sdb").bootDevice(false).durable(false).build())) + .virtualizationType(VirtualizationType.HVM); + } + + /** + * @see InstanceType#I2_2XLARGE + */ + public static EC2HardwareBuilder i2_2xlarge() { + return new EC2HardwareBuilder(InstanceType.I2_2XLARGE).i2() + .ram(61 * 1024) + .processors(ImmutableList.of(new Processor(8.0, 3.375))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(800.0f).device("/dev/sdb").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(800.0f).device("/dev/sdc").bootDevice(false).durable(false).build())) + .virtualizationType(VirtualizationType.HVM); + } + + /** + * @see InstanceType#I2_4XLARGE + */ + public static EC2HardwareBuilder i2_4xlarge() { + return new EC2HardwareBuilder(InstanceType.I2_4XLARGE).i2() + .ram(122 * 1024) + .processors(ImmutableList.of(new Processor(16.0, 3.3125))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(800.0f).device("/dev/sdb").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(800.0f).device("/dev/sdc").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(800.0f).device("/dev/sdd").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(800.0f).device("/dev/sde").bootDevice(false).durable(false).build())) + .virtualizationType(VirtualizationType.HVM); + } + + /** + * @see InstanceType#I2_8XLARGE + */ + public static EC2HardwareBuilder i2_8xlarge() { + return new EC2HardwareBuilder(InstanceType.I2_8XLARGE).i2() + .ram(244 * 1024) + .processors(ImmutableList.of(new Processor(32.0, 3.25))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(800.0f).device("/dev/sdb").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(800.0f).device("/dev/sdc").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(800.0f).device("/dev/sdd").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(800.0f).device("/dev/sde").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(800.0f).device("/dev/sdf").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(800.0f).device("/dev/sdg").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(800.0f).device("/dev/sdh").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(800.0f).device("/dev/sdi").bootDevice(false).durable(false).build())) + .virtualizationType(VirtualizationType.HVM); + } + + public static EC2HardwareBuilder hi1_4xlarge() { + return new EC2HardwareBuilder(InstanceType.HI1_4XLARGE).hi1() + .ram(60 * 1024 + 512) + .processors(ImmutableList.of(new Processor(16.0, 2.1875))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(1024.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(1024.0f).device("/dev/sdb").bootDevice(false).durable(false).build())) + .virtualizationType(VirtualizationType.HVM); + } + + public static EC2HardwareBuilder hs1_8xlarge() { + float twoTB = 2048.0f * 1024.0f; + Builder<Volume> all24Volumes = ImmutableList.<Volume>builder(); + all24Volumes.add(new VolumeBuilder().type(LOCAL).size(twoTB).device("/dev/sda1").bootDevice(true).durable(false).build()); + for (char letter : ImmutableSet.of('b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', + 'q', 'r', 's', 't', 'u', 'v', 'w', 'x')) { + all24Volumes.add(new VolumeBuilder().type(LOCAL).size(twoTB).device("/dev/sd" + letter).bootDevice(false).durable(false).build()); + } + return new EC2HardwareBuilder(InstanceType.HS1_8XLARGE).hs1() + .ram(117 * 1024) + .processors(ImmutableList.of(new Processor(16.0, 2.1875))) + .volumes(all24Volumes.build()) + .virtualizationType(VirtualizationType.HVM); + } + + /** + * @see InstanceType#R3_LARGE + */ + public static EC2HardwareBuilder r3_large() { + return new EC2HardwareBuilder(InstanceType.R3_LARGE).r3() + .ram(15616) + .processors(ImmutableList.of(new Processor(2.0, 2.5))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(32.0f).device("/dev/sdb").bootDevice(false).durable(false).build())); + } + + /** + * @see InstanceType#R3_XLARGE + */ + public static EC2HardwareBuilder r3_xlarge() { + return new EC2HardwareBuilder(InstanceType.R3_XLARGE).r3() + .ram(31232) + .processors(ImmutableList.of(new Processor(4.0, 2.5))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(80.0f).device("/dev/sdb").bootDevice(false).durable(false).build())); + } + + /** + * @see InstanceType#R3_2XLARGE + */ + public static EC2HardwareBuilder r3_2xlarge() { + return new EC2HardwareBuilder(InstanceType.R3_2XLARGE).r3() + .ram(62464) + .processors(ImmutableList.of(new Processor(8.0, 2.5))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(160.0f).device("/dev/sdb").bootDevice(false).durable(false).build())); + } + + /** + * @see InstanceType#R3_4XLARGE + */ + public static EC2HardwareBuilder r3_4xlarge() { + return new EC2HardwareBuilder(InstanceType.R3_4XLARGE).r3() + .ram(124928) + .processors(ImmutableList.of(new Processor(16.0, 2.5))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(320.0f).device("/dev/sdb").bootDevice(false).durable(false).build())); + } + + /** + * @see InstanceType#R3_8XLARGE + */ + public static EC2HardwareBuilder r3_8xlarge() { + return new EC2HardwareBuilder(InstanceType.R3_8XLARGE).r3() + .ram(249856) + .processors(ImmutableList.of(new Processor(32.0, 2.5))) + .volumes(ImmutableList.<Volume> of( + new VolumeBuilder().type(LOCAL).size(10.0f).device("/dev/sda1").bootDevice(true).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(320.0f).device("/dev/sdb").bootDevice(false).durable(false).build(), + new VolumeBuilder().type(LOCAL).size(320.0f).device("/dev/sdc").bootDevice(false).durable(false).build())); + } + + @SuppressWarnings("unchecked") + @Override + public Hardware build() { + Preconditions.checkNotNull(virtualizationType, "virtualizationType"); + boolean reset = false; + if (this.supportsImage == null) + reset = true; + try { + supportsImage = Predicates.<Image> and(rootDeviceType, virtualizationType, imageIds, is64Bit); + return super.build(); + } finally { + if (reset) + this.supportsImage = null; + } + + } + +}
