private void setInstanceInitiatedShutdownBehaviorForInstanceInRegion() {
    try {

      client
          .getInstanceServices()
          .setInstanceInitiatedShutdownBehaviorForInstanceInRegion(
              null, ebsInstance.getId(), InstanceInitiatedShutdownBehavior.STOP);

      assertEquals(
          InstanceInitiatedShutdownBehavior.STOP,
          client
              .getInstanceServices()
              .getInstanceInitiatedShutdownBehaviorForInstanceInRegion(null, ebsInstance.getId()));
      client
          .getInstanceServices()
          .setInstanceInitiatedShutdownBehaviorForInstanceInRegion(
              null, ebsInstance.getId(), InstanceInitiatedShutdownBehavior.TERMINATE);

      assertEquals(
          InstanceInitiatedShutdownBehavior.TERMINATE,
          client
              .getInstanceServices()
              .getInstanceInitiatedShutdownBehaviorForInstanceInRegion(null, ebsInstance.getId()));
      System.out.println("OK: setInstanceInitiatedShutdownBehaviorForInstanceInRegion");
    } catch (Exception e) {
      System.err.println("setInstanceInitiatedShutdownBehaviorForInstanceInRegion");
      e.printStackTrace();
    }
  }
  private void setBlockDeviceMappingForInstanceInRegion() {
    String volumeId = ebsInstance.getEbsBlockDevices().get("/dev/sda1").getVolumeId();

    Map<String, BlockDevice> mapping = Maps.newLinkedHashMap();
    mapping.put("/dev/sda1", new BlockDevice(volumeId, false));
    try {
      client
          .getInstanceServices()
          .setBlockDeviceMappingForInstanceInRegion(null, ebsInstance.getId(), mapping);

      Map<String, BlockDevice> devices =
          client
              .getInstanceServices()
              .getBlockDeviceMappingForInstanceInRegion(null, ebsInstance.getId());
      assertEquals(devices.size(), 1);
      String deviceName = Iterables.getOnlyElement(devices.keySet());
      BlockDevice device = Iterables.getOnlyElement(devices.values());

      assertEquals(device.getVolumeId(), volumeId);
      assertEquals(deviceName, "/dev/sda1");
      assertEquals(device.isDeleteOnTermination(), false);

      System.out.println("OK: setBlockDeviceMappingForInstanceInRegion");
    } catch (Exception e) {
      System.err.println("setBlockDeviceMappingForInstanceInRegion");

      e.printStackTrace();
    }
  }
예제 #3
0
  // Fires up an instance, finds its root volume ID, takes a snapshot, then
  // terminates the instance.
  private Snapshot createSnapshot() throws RunNodesException {

    String instanceId = null;
    try {
      RunningInstance instance =
          getOnlyElement(
              concat(
                  ec2Client
                      .getInstanceServices()
                      .runInstancesInRegion(regionId, null, imageId, 1, 1)));
      instanceId = instance.getId();

      assertTrue(runningTester.apply(instance), instanceId + "didn't achieve the state running!");

      instance =
          getOnlyElement(
              concat(
                  ec2Client.getInstanceServices().describeInstancesInRegion(regionId, instanceId)));
      BlockDevice device = instance.getEbsBlockDevices().get("/dev/sda1");
      assertNotNull(device, "device: /dev/sda1 not present on: " + instance);
      Snapshot snapshot =
          ec2Client
              .getElasticBlockStoreServices()
              .createSnapshotInRegion(regionId, device.getVolumeId());
      snapshotsToDelete.add(snapshot.getId());
      return snapshot;
    } finally {
      if (instanceId != null)
        ec2Client.getInstanceServices().terminateInstancesInRegion(regionId, instanceId);
    }
  }
  @VisibleForTesting
  static List<Volume> addEBS(final RunningInstance instance, Iterable<? extends Volume> volumes) {
    Iterable<Volume> ebsVolumes =
        Iterables.transform(
            instance.getEbsBlockDevices().entrySet(),
            new Function<Entry<String, BlockDevice>, Volume>() {

              @Override
              public Volume apply(Entry<String, BlockDevice> from) {
                return new VolumeImpl(
                    from.getValue().getVolumeId(),
                    Volume.Type.SAN,
                    null,
                    from.getKey(),
                    instance.getRootDeviceName() != null
                        && instance.getRootDeviceName().equals(from.getKey()),
                    true);
              }
            });

    if (instance.getRootDeviceType() == RootDeviceType.EBS) {
      volumes =
          Iterables.filter(
              volumes,
              new Predicate<Volume>() {

                @Override
                public boolean apply(Volume input) {
                  return !input.isBootDevice();
                }
              });
    }
    return Lists.newArrayList(Iterables.concat(volumes, ebsVolumes));
  }
 private void setKernelForInstanceInRegion() {
   String oldKernel =
       client.getInstanceServices().getKernelForInstanceInRegion(null, ebsInstance.getId());
   client.getInstanceServices().setKernelForInstanceInRegion(null, ebsInstance.getId(), oldKernel);
   assertEquals(
       oldKernel,
       client.getInstanceServices().getKernelForInstanceInRegion(null, ebsInstance.getId()));
 }
 private void setRamdiskForInstanceInRegion() {
   String ramdisk =
       client.getInstanceServices().getRamdiskForInstanceInRegion(null, ebsInstance.getId());
   client.getInstanceServices().setRamdiskForInstanceInRegion(null, ebsInstance.getId(), ramdisk);
   assertEquals(
       ramdisk,
       client.getInstanceServices().getRamdiskForInstanceInRegion(null, ebsInstance.getId()));
 }
 private void setUserDataForInstanceInRegion() {
   client
       .getInstanceServices()
       .setUserDataForInstanceInRegion(null, ebsInstance.getId(), "test".getBytes());
   assertEquals(
       "test",
       client.getInstanceServices().getUserDataForInstanceInRegion(null, ebsInstance.getId()));
 }
 @VisibleForTesting
 String getGroupForInstance(final RunningInstance instance) {
   String group = parseGroupFrom(instance, instance.getGroupNames());
   if (group == null && instance.getKeyName() != null) {
     // when not using a generated security group, e.g. in VPC, try from key:
     group = parseGroupFrom(instance, Sets.newHashSet(instance.getKeyName()));
   }
   return group;
 }
 private void setInstanceTypeForInstanceInRegion() {
   client
       .getInstanceServices()
       .setInstanceTypeForInstanceInRegion(null, ebsInstance.getId(), InstanceType.C1_MEDIUM);
   assertEquals(
       InstanceType.C1_MEDIUM,
       client.getInstanceServices().getInstanceTypeForInstanceInRegion(null, ebsInstance.getId()));
   client
       .getInstanceServices()
       .setInstanceTypeForInstanceInRegion(null, ebsInstance.getId(), InstanceType.M1_SMALL);
   assertEquals(
       InstanceType.M1_SMALL,
       client.getInstanceServices().getInstanceTypeForInstanceInRegion(null, ebsInstance.getId()));
 }
 private String parseGroupFrom(final RunningInstance instance, final Set<String> data) {
   String group = null;
   try {
     Predicate<String> containsAnyGroup = namingConvention.create().containsAnyGroup();
     String encodedGroup = Iterables.getOnlyElement(Iterables.filter(data, containsAnyGroup));
     group = namingConvention.create().extractGroup(encodedGroup);
   } catch (NoSuchElementException e) {
     logger.debug("no group parsed from %s's data: %s", instance.getId(), data);
   } catch (IllegalArgumentException e) {
     logger.debug(
         "too many groups match naming convention; %s's data: %s", instance.getId(), data);
   }
   return group;
 }
 @Override
 protected void addCredentialsForInstance(NodeMetadataBuilder builder, RunningInstance instance) {
   LoginCredentials creds =
       LoginCredentials.fromCredentials(
           credentialStore.get("node#" + instance.getRegion() + "/" + instance.getId()));
   String spotRequestId = AWSRunningInstance.class.cast(instance).getSpotInstanceRequestId();
   if (creds == null && spotRequestId != null) {
     creds =
         LoginCredentials.fromCredentials(
             credentialStore.get("node#" + instance.getRegion() + "/" + spotRequestId));
     if (creds != null)
       credentialStore.put("node#" + instance.getRegion() + "/" + instance.getId(), creds);
   }
   if (creds != null) builder.credentials(creds);
 }
 @Override
 public NodeMetadata apply(RunningInstance instance) {
   if (instance == null || instance.getId() == null) return null;
   NodeMetadataBuilder builder = new NodeMetadataBuilder();
   builder = buildInstance(instance, builder);
   return builder.build();
 }
  private RunningInstance blockUntilWeCanSshIntoInstance(RunningInstance instance)
      throws UnknownHostException {
    System.out.printf(
        "%d: %s awaiting instance to run %n", System.currentTimeMillis(), instance.getId());
    assert runningTester.apply(instance);

    // search my identity for the instance I just created
    Set<? extends Reservation<? extends RunningInstance>> reservations =
        client
            .getInstanceServices()
            .describeInstancesInRegion(instance.getRegion(), instance.getId()); // last
    // parameter
    // (ids)
    // narrows
    // the
    // search

    instance = Iterables.getOnlyElement(Iterables.getOnlyElement(reservations));

    System.out.printf(
        "%d: %s awaiting ssh service to start%n",
        System.currentTimeMillis(), instance.getIpAddress());
    assert socketTester.apply(new IPSocket(instance.getIpAddress(), 22));
    System.out.printf(
        "%d: %s ssh service started%n", System.currentTimeMillis(), instance.getDnsName());
    sshPing(instance);
    System.out.printf("%d: %s ssh connection made%n", System.currentTimeMillis(), instance.getId());
    return instance;
  }
  @Test(
      enabled = false,
      dependsOnMethods = {"testAMIFromBundle"})
  public void testInstanceFromEBS() throws Exception {
    System.out.printf(
        "%d: %s creating instance from ebs-backed ami%n",
        System.currentTimeMillis(), ebsImage.getId());

    ebsInstance = createInstance(ebsImage.getId());

    client
        .getInstanceServices()
        .stopInstancesInRegion(ebsInstance.getRegion(), true, ebsInstance.getId());

    System.out.printf(
        "%d: %s awaiting instance to stop %n", System.currentTimeMillis(), ebsInstance.getId());
    stoppedTester.apply(ebsInstance);
    tryToChangeStuff();
    System.out.printf(
        "%d: %s awaiting instance to start %n", System.currentTimeMillis(), ebsInstance.getId());
    client
        .getInstanceServices()
        .startInstancesInRegion(ebsInstance.getRegion(), ebsInstance.getId());
    ebsInstance = blockUntilWeCanSshIntoInstance(ebsInstance);
  }
  @Test(enabled = false, dependsOnMethods = "testCreateAndAttachVolume")
  void testBundleInstance() {
    SshClient ssh =
        sshFactory.create(
            new IPSocket(instance.getIpAddress(), 22),
            new Credentials("ubuntu", keyPair.getKeyMaterial()));
    try {
      ssh.connect();
    } catch (SshException e) { // try twice in case there is a network timeout
      try {
        Thread.sleep(10 * 1000);
      } catch (InterruptedException e1) {
      }
      ssh.connect();
    }
    try {
      System.out.printf(
          "%d: %s writing ebs script%n", System.currentTimeMillis(), instance.getId());
      String script = "/tmp/mkebsboot-init.sh";
      ssh.put(script, Payloads.newStringPayload(mkEbsBoot));

      System.out.printf(
          "%d: %s launching ebs script%n", System.currentTimeMillis(), instance.getId());
      ssh.exec("chmod 755 " + script);
      ssh.exec(script + " init");
      ExecResponse output = ssh.exec("sudo " + script + " start");
      System.out.println(output);
      output = ssh.exec(script + " status");

      assert !output.getOutput().trim().equals("") : output;

      RetryablePredicate<String> scriptTester =
          new RetryablePredicate<String>(
              new ScriptTester(ssh, SCRIPT_END), 600, 10, TimeUnit.SECONDS);
      scriptTester.apply(script);
    } finally {
      if (ssh != null) ssh.disconnect();
    }
  }
  public void testEBS() throws UnknownHostException {

    Set<Reservation<RunningInstance>> contents =
        ImmutableSet.of(
            new Reservation<RunningInstance>(
                defaultRegion,
                ImmutableSet.of("adriancole.ec2ebsingress"),
                ImmutableSet.of(
                    RunningInstance.builder()
                        .region(defaultRegion)
                        .groupName("adriancole.ec2ebsingress")
                        .amiLaunchIndex("0")
                        .dnsName("ec2-75-101-203-146.compute-1.amazonaws.com")
                        .imageId("ami-849875ed")
                        .instanceId("i-e564438d")
                        .instanceState(InstanceState.RUNNING)
                        .rawState("running")
                        .instanceType(InstanceType.M1_SMALL)
                        .ipAddress("75.101.203.146")
                        .kernelId("aki-a71cf9ce")
                        .keyName("adriancole.ec2ebs1")
                        .launchTime(dateService.iso8601DateParse("2009-12-30T04:06:23.000Z"))
                        // MonitoringState.DISABLED
                        .availabilityZone("us-east-1b")
                        // "placement"
                        .virtualizationType("hvm")
                        .privateDnsName("domU-12-31-39-09-CE-53.compute-1.internal")
                        .privateIpAddress("10.210.209.157")
                        .ramdiskId("ari-a51cf9cc")
                        .rootDeviceType(RootDeviceType.EBS)
                        .rootDeviceName("/dev/sda1")
                        .device(
                            "/dev/sda1",
                            new BlockDevice(
                                "vol-dc6ca8b5",
                                Attachment.Status.ATTACHED,
                                dateService.iso8601DateParse("2009-12-30T04:06:29.000Z"),
                                true))
                        .build()),
                "993194456877",
                null,
                "r-596dd731"));

    Set<Reservation<? extends RunningInstance>> result =
        parseRunningInstances("/describe_instances_ebs.xml");

    assertEquals(result.toString(), contents.toString());
    assertEquals(get(get(result, 0), 0).getInstanceState(), InstanceState.RUNNING);
    assertEquals(get(get(result, 0), 0).getRawState(), "running");
  }
 private RunningInstance createInstance(String imageId) throws UnknownHostException {
   RunningInstance instance = null;
   while (instance == null) {
     try {
       System.out.printf("%d: running instance%n", System.currentTimeMillis());
       Reservation<? extends RunningInstance> reservation =
           client
               .getInstanceServices()
               .runInstancesInRegion(
                   null,
                   null, // allow
                   // ec2
                   // to
                   // chose
                   // an
                   // availability
                   // zone
                   imageId,
                   1, // minimum instances
                   1, // maximum instances
                   withKeyName(keyPair.getKeyName()) // key I created above
                       .asType(InstanceType.M1_SMALL) // smallest instance
                       // size
                       .withSecurityGroup(securityGroupName)); // group I
       // created
       // above
       instance = Iterables.getOnlyElement(reservation);
     } catch (HttpResponseException htpe) {
       if (htpe.getResponse().getStatusCode() == 400) continue;
       throw htpe;
     }
   }
   assertNotNull(instance.getId());
   assertEquals(instance.getInstanceState(), InstanceState.PENDING);
   instance = blockUntilWeCanSshIntoInstance(instance);
   return instance;
 }
  @Test(enabled = false, dependsOnMethods = "testCreateRunningInstance")
  void testCreateAndAttachVolume() {
    volume =
        client
            .getElasticBlockStoreServices()
            .createVolumeInAvailabilityZone(instance.getAvailabilityZone(), VOLUME_SIZE);
    System.out.printf(
        "%d: %s awaiting volume to become available%n", System.currentTimeMillis(), volume.getId());

    assert volumeTester.apply(volume);

    Attachment attachment =
        client
            .getElasticBlockStoreServices()
            .attachVolumeInRegion(
                instance.getRegion(), volume.getId(), instance.getId(), "/dev/sdh");

    System.out.printf(
        "%d: %s awaiting attachment to complete%n", System.currentTimeMillis(), attachment.getId());

    assert attachTester.apply(attachment);
    System.out.printf(
        "%d: %s attachment complete%n", System.currentTimeMillis(), attachment.getId());
  }
  @VisibleForTesting
  Hardware getHardwareForInstance(final RunningInstance instance) {
    try {
      return Iterables.find(
          hardware.get(),
          new Predicate<Hardware>() {

            @Override
            public boolean apply(Hardware input) {
              return input.getId().equals(instance.getInstanceType());
            }
          });
    } catch (NoSuchElementException e) {
      logger.debug(
          "couldn't match instance type %s in: %s", instance.getInstanceType(), hardware.get());
      return null;
    }
  }
  public void testWhenRunning() throws UnknownHostException {

    Set<Reservation<RunningInstance>> contents =
        ImmutableSet.of(
            new Reservation<RunningInstance>(
                defaultRegion,
                ImmutableSet.of("adriancole.ec2ingress"),
                ImmutableSet.of(
                    RunningInstance.builder()
                        .region(defaultRegion)
                        .groupName("adriancole.ec2ingress")
                        .amiLaunchIndex("0")
                        .dnsName("ec2-174-129-81-68.compute-1.amazonaws.com")
                        .imageId("ami-82e4b5c7")
                        .instanceId("i-0799056f")
                        .instanceState(InstanceState.RUNNING)
                        .rawState("running")
                        .instanceType(InstanceType.M1_SMALL)
                        .ipAddress("174.129.81.68")
                        .kernelId("aki-a71cf9ce")
                        .keyName("adriancole.ec21")
                        .launchTime(dateService.iso8601DateParse("2009-11-09T03:00:34.000Z"))
                        // MonitoringState.DISABLED,
                        .availabilityZone("us-east-1c")
                        .virtualizationType("paravirtual")
                        .privateDnsName("ip-10-243-42-70.ec2.internal")
                        .privateIpAddress("10.243.42.70")
                        .ramdiskId("ari-a51cf9cc")
                        .rootDeviceType(RootDeviceType.INSTANCE_STORE)
                        .build()),
                "993194456877",
                null,
                "r-a3c508cb"));

    Set<Reservation<? extends RunningInstance>> result =
        parseRunningInstances("/describe_instances_running.xml");

    assertEquals(result.toString(), contents.toString());
    assertEquals(get(get(result, 0), 0).getInstanceState(), InstanceState.RUNNING);
    assertEquals(get(get(result, 0), 0).getRawState(), "running");
  }
  @AfterTest
  void cleanup() {
    if (ebsInstance != null) {
      try {
        client
            .getInstanceServices()
            .terminateInstancesInRegion(ebsInstance.getRegion(), ebsInstance.getId());
        terminatedTester.apply(ebsInstance);
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
    if (ebsImage != null) {
      try {
        client.getAMIServices().deregisterImageInRegion(ebsImage.getRegion(), ebsImage.getId());
      } catch (Exception e) {
        e.printStackTrace();
      }
    }

    if (snapshot != null) {
      try {
        client
            .getElasticBlockStoreServices()
            .deleteSnapshotInRegion(snapshot.getRegion(), snapshot.getId());
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
    if (attachment != null) {
      try {
        client
            .getElasticBlockStoreServices()
            .detachVolumeInRegion(volume.getRegion(), volume.getId(), true);
        assert volumeTester.apply(volume);
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
    if (instance != null) {
      try {
        client
            .getInstanceServices()
            .terminateInstancesInRegion(instance.getRegion(), instance.getId());
        terminatedTester.apply(instance);
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
    if (volume != null) {
      try {
        client
            .getElasticBlockStoreServices()
            .deleteVolumeInRegion(volume.getRegion(), volume.getId());
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
    if (keyPair != null) {
      try {
        client
            .getKeyPairServices()
            .deleteKeyPairInRegion(keyPair.getRegion(), keyPair.getKeyName());
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
    if (securityGroupName != null) {
      try {
        client.getSecurityGroupServices().deleteSecurityGroupInRegion(null, securityGroupName);
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
  }
 private void doCheckKey(RunningInstance newDetails) throws UnknownHostException {
   doCheckKey(newDetails.getIpAddress());
 }
  protected NodeMetadataBuilder buildInstance(
      final RunningInstance instance, NodeMetadataBuilder builder) {
    builder.providerId(instance.getId());
    builder.id(instance.getRegion() + "/" + instance.getId());
    String group = getGroupForInstance(instance);
    builder.group(group);
    // standard convention from aws-ec2, which might not be re-used outside.
    if (instance.getPrivateDnsName() != null)
      builder.hostname(instance.getPrivateDnsName().replaceAll("\\..*", ""));
    addCredentialsForInstance(builder, instance);
    builder.status(instanceToNodeStatus.get(instance.getInstanceState()));
    builder.backendStatus(instance.getRawState());

    // collect all ip addresses into one bundle in case the api mistakenly put a private address
    // into the public address field
    Builder<String> addressesBuilder = ImmutableSet.builder();
    if (Strings.emptyToNull(instance.getIpAddress()) != null)
      addressesBuilder.add(instance.getIpAddress());
    // Add dnsName (if available) to addresses, when the IPAddress is null
    // happens on Eucalyptus sometimes.
    else if (Strings.emptyToNull(instance.getDnsName()) != null)
      addressesBuilder.add(instance.getDnsName());
    if (Strings.emptyToNull(instance.getPrivateIpAddress()) != null)
      addressesBuilder.add(instance.getPrivateIpAddress());

    Set<String> addresses = addressesBuilder.build();

    builder.publicAddresses(filter(addresses, not(IsPrivateIPAddress.INSTANCE)));
    builder.privateAddresses(filter(addresses, IsPrivateIPAddress.INSTANCE));
    builder.hardware(parseHardware(instance));
    Location location = getLocationForAvailabilityZoneOrRegion(instance);
    builder.location(location);
    builder.imageId(instance.getRegion() + "/" + instance.getImageId());

    // extract the operating system from the image
    RegionAndName regionAndName = new RegionAndName(instance.getRegion(), instance.getImageId());
    try {
      Image image = imageMap.get().getUnchecked(regionAndName);
      if (image != null) builder.operatingSystem(image.getOperatingSystem());
    } catch (CacheLoader.InvalidCacheLoadException e) {
      logger.debug("image not found for %s: %s", regionAndName, e);
    } catch (UncheckedExecutionException e) {
      logger.debug("error getting image for %s: %s", regionAndName, e);
    }
    return builder;
  }
 protected void addCredentialsForInstance(NodeMetadataBuilder builder, RunningInstance instance) {
   builder.credentials(
       LoginCredentials.fromCredentials(
           credentialStore.get("node#" + instance.getRegion() + "/" + instance.getId())));
 }
 private Location getLocationForAvailabilityZoneOrRegion(final RunningInstance instance) {
   Location location = findLocationWithId(instance.getAvailabilityZone());
   if (location == null) location = findLocationWithId(instance.getRegion());
   return location;
 }
  public void testApplyInputStream() {
    Set<Reservation<RunningInstance>> contents =
        ImmutableSet.of(
            new Reservation<RunningInstance>(
                defaultRegion,
                ImmutableSet.of("default"),
                ImmutableSet.of(
                    RunningInstance.builder()
                        .region(defaultRegion)
                        .groupName("default")
                        .amiLaunchIndex("23")
                        .dnsName("ec2-72-44-33-4.compute-1.amazonaws.com")
                        .imageId("ami-6ea54007")
                        .instanceId("i-28a64341")
                        .instanceState(InstanceState.RUNNING)
                        .rawState("running")
                        .instanceType(InstanceType.M1_LARGE)
                        .kernelId("aki-ba3adfd3")
                        .keyName("example-key-name")
                        .launchTime(dateService.iso8601DateParse("2007-08-07T11:54:42.000Z"))
                        // MonitoringState.DISABLED,
                        .availabilityZone("us-east-1b")
                        .virtualizationType("paravirtual")
                        .privateDnsName("10-251-50-132.ec2.internal") // product codes
                        // ImmutableSet.of("774F4FF8")
                        .tags(ImmutableMap.of("Name", "ec2-o", "Empty", ""))
                        .ramdiskId("ari-badbad00")
                        .rootDeviceType(RootDeviceType.INSTANCE_STORE)
                        .build(),
                    RunningInstance.builder()
                        .region(defaultRegion)
                        .groupName("default")
                        .amiLaunchIndex("23")
                        .dnsName("ec2-72-44-33-6.compute-1.amazonaws.com")
                        .imageId("ami-6ea54007")
                        .instanceId("i-28a64435")
                        .instanceState(InstanceState.RUNNING)
                        .rawState("running")
                        .instanceType(InstanceType.M1_LARGE)
                        .kernelId("aki-ba3adfd3")
                        .keyName("example-key-name")
                        .launchTime(dateService.iso8601DateParse("2007-08-07T11:54:42.000Z"))
                        // MonitoringState.DISABLED,
                        .availabilityZone("us-east-1b")
                        .virtualizationType("paravirtual")
                        .privateDnsName("10-251-50-134.ec2.internal") // product codes
                        // ImmutableSet.of("774F4FF8")
                        .ramdiskId("ari-badbad00")
                        .rootDeviceType(RootDeviceType.INSTANCE_STORE)
                        .build()),
                "UYY3TLBUXIEON5NQVUUX6OMPWBZIQNFM",
                null,
                "r-44a5402d"));

    Set<Reservation<? extends RunningInstance>> result =
        parseRunningInstances("/describe_instances.xml");

    assertEquals(result.toString(), contents.toString());
    assertEquals(get(get(result, 0), 0).getInstanceState(), InstanceState.RUNNING);
    assertEquals(get(get(result, 0), 0).getRawState(), "running");
  }
  @Test(enabled = false, dependsOnMethods = "testBundleInstance")
  void testAMIFromBundle() {
    volume =
        Iterables.getOnlyElement(
            client
                .getElasticBlockStoreServices()
                .describeVolumesInRegion(volume.getRegion(), volume.getId()));
    if (volume.getAttachments().size() > 0) {
      // should be cleanly unmounted, so force is not necessary.
      client
          .getElasticBlockStoreServices()
          .detachVolumeInRegion(instance.getRegion(), volume.getId(), false);
      System.out.printf(
          "%d: %s awaiting detachment to complete%n", System.currentTimeMillis(), volume.getId());
      assert volumeTester.apply(volume);
    } else {
      attachment = null; // protect test closer so that it doesn't try to
      // detach
    }
    snapshot =
        client
            .getElasticBlockStoreServices()
            .createSnapshotInRegion(
                volume.getRegion(), volume.getId(), withDescription("EBS Ubuntu Hardy"));

    System.out.printf(
        "%d: %s awaiting snapshot to complete%n", System.currentTimeMillis(), snapshot.getId());

    assert snapshotTester.apply(snapshot);
    Image image =
        Iterables.getOnlyElement(
            client
                .getAMIServices()
                .describeImagesInRegion(snapshot.getRegion(), imageIds(IMAGE_ID)));
    String description = image.getDescription() == null ? "jclouds" : image.getDescription();

    System.out.printf(
        "%d: %s creating ami from snapshot%n", System.currentTimeMillis(), snapshot.getId());

    String amiId =
        client
            .getAMIServices()
            .registerUnixImageBackedByEbsInRegion(
                snapshot.getRegion(),
                "ebsboot-" + image.getId(),
                snapshot.getId(),
                withKernelId(image.getKernelId())
                    .withRamdisk(image.getRamdiskId())
                    .withDescription(description)
                    .asArchitecture(Architecture.I386));
    try {
      ebsImage =
          Iterables.getOnlyElement(
              client
                  .getAMIServices()
                  .describeImagesInRegion(snapshot.getRegion(), imageIds(amiId)));
    } catch (AWSResponseException e) {
      // TODO add a retry handler for this HTTP code 400 and the below error
      if (e.getError().getClass().equals("InvalidAMIID.NotFound"))
        ebsImage =
            Iterables.getOnlyElement(
                client
                    .getAMIServices()
                    .describeImagesInRegion(snapshot.getRegion(), imageIds(amiId)));
      else throw e;
    }
    verifyImage();
  }
 @Override
 public RegionAndName apply(RunningInstance from) {
   return new RegionAndName(from.getRegion(), from.getId());
 }
  @SuppressWarnings("unchecked")
  private void assertRegionAndZoneForLocation(Location location, String region, String zone) {
    String imageId = "ami1";
    String instanceCreatedId = "instance1";
    // setup mocks
    TemplateBuilder templateBuilder = createMock(TemplateBuilder.class);
    EC2CreateNodesInGroupThenAddToSet strategy = setupStrategy(templateBuilder);
    InputParams input = new InputParams(location);
    InstanceClient instanceClient = createMock(InstanceClient.class);
    RunInstancesOptions ec2Options = createMock(RunInstancesOptions.class);
    RunningInstance instance = createMock(RunningInstance.class);
    Reservation<? extends RunningInstance> reservation =
        new Reservation<RunningInstance>(
            region,
            ImmutableSet.<String>of(),
            ImmutableSet.<RunningInstance>of(instance),
            "ownerId",
            "requesterId",
            "reservationId");
    NodeMetadata nodeMetadata = createMock(NodeMetadata.class);

    // setup expectations
    expect(templateBuilder.fromTemplate(input.template)).andReturn(templateBuilder);
    expect(templateBuilder.build()).andReturn(input.template);
    expect(strategy.client.getInstanceServices()).andReturn(instanceClient).atLeastOnce();
    expect(
            strategy.createKeyPairAndSecurityGroupsAsNeededAndReturncustomize.execute(
                region, input.tag, input.template))
        .andReturn(ec2Options);
    expect(input.template.getLocation()).andReturn(input.location).atLeastOnce();
    expect(input.template.getImage()).andReturn(input.image).atLeastOnce();
    expect(input.image.getProviderId()).andReturn(imageId).atLeastOnce();
    expect(instanceClient.runInstancesInRegion(region, zone, imageId, 1, input.count, ec2Options))
        .andReturn(Reservation.class.cast(reservation));
    expect(instance.getId()).andReturn(instanceCreatedId).atLeastOnce();
    // simulate a lazy credentials fetch
    Credentials creds = new Credentials("foo", "bar");
    expect(strategy.instanceToCredentials.apply(instance)).andReturn(creds);
    expect(instance.getRegion()).andReturn(region).atLeastOnce();
    expect(strategy.credentialStore.put("node#" + region + "/" + instanceCreatedId, creds))
        .andReturn(null);

    expect(strategy.instancePresent.apply(new RegionAndName(region, instanceCreatedId)))
        .andReturn(true);
    expect(input.template.getOptions()).andReturn(input.options).atLeastOnce();

    expect(strategy.runningInstanceToNodeMetadata.apply(instance)).andReturn(nodeMetadata);
    expect(
            strategy.utils.customizeNodesAndAddToGoodMapOrPutExceptionIntoBadMap(
                eq(input.options),
                containsNodeMetadata(nodeMetadata),
                eq(input.nodes),
                eq(input.badNodes),
                eq(input.customization)))
        .andReturn(null);

    // replay mocks
    replay(templateBuilder);
    replay(instanceClient);
    replay(ec2Options);
    replay(instance);
    replay(nodeMetadata);
    input.replayMe();
    replayStrategy(strategy);

    // run
    strategy.execute(
        input.tag, input.count, input.template, input.nodes, input.badNodes, input.customization);

    // verify mocks
    verify(templateBuilder);
    verify(instanceClient);
    verify(ec2Options);
    verify(instance);
    verify(nodeMetadata);
    input.verifyMe();
    verifyStrategy(strategy);
  }