@Override
public ResourceAction perform(
ResourceAction oldResourceAction, ResourceAction newResourceAction) throws Exception {
AWSEC2VolumeResourceAction oldAction = (AWSEC2VolumeResourceAction) oldResourceAction;
AWSEC2VolumeResourceAction newAction = (AWSEC2VolumeResourceAction) newResourceAction;
ServiceConfiguration configuration = Topology.lookup(Compute.class);
DescribeVolumeAttributeType describeVolumeAttributeType =
MessageHelper.createMessage(
DescribeVolumeAttributeType.class, newAction.info.getEffectiveUserId());
describeVolumeAttributeType.setVolumeId(newAction.info.getPhysicalResourceId());
describeVolumeAttributeType.setAttribute("autoEnableIO");
DescribeVolumeAttributeResponseType describeVolumeAttributeResponseType =
AsyncRequests.sendSync(configuration, describeVolumeAttributeType);
Boolean originalValue = null;
if (describeVolumeAttributeResponseType != null) {
originalValue = describeVolumeAttributeResponseType.getAutoEnableIO();
}
if (!Objects.equals(originalValue, newAction.properties.getAutoEnableIO())) {
ModifyVolumeAttributeType modifyVolumeAttributeTypeType =
MessageHelper.createMessage(
ModifyVolumeAttributeType.class, newAction.info.getEffectiveUserId());
modifyVolumeAttributeTypeType.setVolumeId(newAction.info.getPhysicalResourceId());
modifyVolumeAttributeTypeType.setAutoEnableIO(newAction.properties.getAutoEnableIO());
AsyncRequests.sendSync(configuration, modifyVolumeAttributeTypeType);
}
return newAction;
}
@Override
public ResourceAction perform(ResourceAction resourceAction) throws Exception {
AWSEC2VolumeResourceAction action = (AWSEC2VolumeResourceAction) resourceAction;
ServiceConfiguration configuration = Topology.lookup(Compute.class);
// Create 'system' tags as admin user
String effectiveAdminUserId =
Accounts.lookupPrincipalByAccountNumber(
Accounts.lookupPrincipalByUserId(action.info.getEffectiveUserId())
.getAccountNumber())
.getUserId();
CreateTagsType createSystemTagsType =
MessageHelper.createPrivilegedMessage(CreateTagsType.class, effectiveAdminUserId);
createSystemTagsType.setResourcesSet(
Lists.newArrayList(action.info.getPhysicalResourceId()));
createSystemTagsType.setTagSet(
EC2Helper.createTagSet(
TagHelper.getEC2SystemTags(action.info, action.getStackEntity())));
AsyncRequests.<CreateTagsType, CreateTagsResponseType>sendSync(
configuration, createSystemTagsType);
// Create non-system tags as regular user
List<EC2Tag> tags = TagHelper.getEC2StackTags(action.getStackEntity());
if (action.properties.getTags() != null && !action.properties.getTags().isEmpty()) {
TagHelper.checkReservedEC2TemplateTags(action.properties.getTags());
tags.addAll(action.properties.getTags());
}
if (!tags.isEmpty()) {
CreateTagsType createTagsType =
MessageHelper.createMessage(CreateTagsType.class, action.info.getEffectiveUserId());
createTagsType.setResourcesSet(Lists.newArrayList(action.info.getPhysicalResourceId()));
createTagsType.setTagSet(EC2Helper.createTagSet(tags));
AsyncRequests.<CreateTagsType, CreateTagsResponseType>sendSync(
configuration, createTagsType);
}
return action;
}
@Override
public ResourceAction perform(
ResourceAction oldResourceAction, ResourceAction newResourceAction) throws Exception {
AWSIAMInstanceProfileResourceAction oldAction =
(AWSIAMInstanceProfileResourceAction) oldResourceAction;
AWSIAMInstanceProfileResourceAction newAction =
(AWSIAMInstanceProfileResourceAction) newResourceAction;
ServiceConfiguration configuration = Topology.lookup(Euare.class);
// This is a weird case. There can be only 1 role per instance profile, but the API might
// allow more.
// As such, we delete the current role if it exists.
GetInstanceProfileType getInstanceProfileType =
MessageHelper.createMessage(
GetInstanceProfileType.class, newAction.info.getEffectiveUserId());
getInstanceProfileType.setInstanceProfileName(newAction.info.getPhysicalResourceId());
GetInstanceProfileResponseType getInstanceProfileResponseType =
AsyncRequests.<GetInstanceProfileType, GetInstanceProfileResponseType>sendSync(
configuration, getInstanceProfileType);
for (String roleName : getRoleNames(getInstanceProfileResponseType)) {
RemoveRoleFromInstanceProfileType removeRoleFromInstanceProfileType =
MessageHelper.createMessage(
RemoveRoleFromInstanceProfileType.class, newAction.info.getEffectiveUserId());
removeRoleFromInstanceProfileType.setInstanceProfileName(
newAction.info.getPhysicalResourceId());
removeRoleFromInstanceProfileType.setRoleName(roleName);
AsyncRequests
.<RemoveRoleFromInstanceProfileType, RemoveRoleFromInstanceProfileResponseType>
sendSync(configuration, removeRoleFromInstanceProfileType);
}
if (newAction.properties.getRoles() != null) {
if (newAction.properties.getRoles().size() == 0)
throw new ValidationErrorException("Property Roles can not be empty.");
if (newAction.properties.getRoles().size() > 1)
throw new ValidationErrorException("Roles has too many elements. The limit is 1.");
for (String roleName : newAction.properties.getRoles()) {
AddRoleToInstanceProfileType addRoleToInstanceProfileType =
MessageHelper.createMessage(
AddRoleToInstanceProfileType.class, newAction.info.getEffectiveUserId());
addRoleToInstanceProfileType.setInstanceProfileName(
newAction.info.getPhysicalResourceId());
addRoleToInstanceProfileType.setRoleName(roleName);
AsyncRequests
.<AddRoleToInstanceProfileType, AddRoleToInstanceProfileResponseType>sendSync(
configuration, addRoleToInstanceProfileType);
}
}
return newAction;
}
@Override
public ResourceAction perform(ResourceAction resourceAction) throws Exception {
AWSEC2VolumeResourceAction action = (AWSEC2VolumeResourceAction) resourceAction;
ServiceConfiguration configuration = Topology.lookup(Compute.class);
if (volumeDeleted(action, configuration)) return action;
if (!("Snapshot".equals(action.info.getDeletionPolicy()))) return action;
DescribeSnapshotsType describeSnapshotsType =
MessageHelper.createMessage(
DescribeSnapshotsType.class, action.info.getEffectiveUserId());
String snapshotId =
JsonHelper.getJsonNodeFromString(action.info.getSnapshotIdForDelete()).asText();
describeSnapshotsType.getFilterSet().add(Filter.filter("snapshot-id", snapshotId));
DescribeSnapshotsResponseType describeSnapshotsResponseType =
AsyncRequests.sendSync(configuration, describeSnapshotsType);
if (describeSnapshotsResponseType.getSnapshotSet() == null
|| describeSnapshotsResponseType.getSnapshotSet().isEmpty()) {
throw new RetryAfterConditionCheckFailedException(
"Snapshot " + snapshotId + " not yet complete");
}
if ("error".equals(describeSnapshotsResponseType.getSnapshotSet().get(0).getStatus())) {
throw new ResourceFailureException(
"Error creating snapshot "
+ snapshotId
+ ", while deleting volume "
+ action.info.getPhysicalResourceId());
} else if (!"completed"
.equals(describeSnapshotsResponseType.getSnapshotSet().get(0).getStatus())) {
throw new RetryAfterConditionCheckFailedException(
"Snapshot " + snapshotId + " not yet complete");
}
return action;
}
@Override
public ResourceAction perform(ResourceAction resourceAction) throws Exception {
AWSEC2VolumeResourceAction action = (AWSEC2VolumeResourceAction) resourceAction;
ServiceConfiguration configuration = Topology.lookup(Compute.class);
DescribeVolumesType describeVolumesType =
MessageHelper.createMessage(
DescribeVolumesType.class, action.info.getEffectiveUserId());
describeVolumesType
.getFilterSet()
.add(Filter.filter("volume-id", action.info.getPhysicalResourceId()));
DescribeVolumesResponseType describeVolumesResponseType;
try {
describeVolumesResponseType = AsyncRequests.sendSync(configuration, describeVolumesType);
} catch (final Exception e) {
throw new ValidationErrorException(
"Error describing volume "
+ action.info.getPhysicalResourceId()
+ ":"
+ asWebServiceErrorMessage(e, e.getMessage()));
}
if (describeVolumesResponseType.getVolumeSet().size() == 0) {
throw new RetryAfterConditionCheckFailedException(
"Volume " + action.info.getPhysicalResourceId() + " not yet available");
}
if (!"available".equals(describeVolumesResponseType.getVolumeSet().get(0).getStatus())) {
throw new RetryAfterConditionCheckFailedException(
"Volume " + action.info.getPhysicalResourceId() + " not yet available");
}
return action;
}
@Override
public ResourceAction perform(ResourceAction resourceAction) throws Exception {
AWSEC2VolumeResourceAction action = (AWSEC2VolumeResourceAction) resourceAction;
ServiceConfiguration configuration = Topology.lookup(Compute.class);
CreateVolumeType createVolumeType =
MessageHelper.createMessage(CreateVolumeType.class, action.info.getEffectiveUserId());
createVolumeType.setAvailabilityZone(action.properties.getAvailabilityZone());
if (action.properties.getEncrypted() != null) {
createVolumeType.setEncrypted(action.properties.getEncrypted());
}
// KmsKeyId not supported
if (action.properties.getIops() != null) {
createVolumeType.setIops(action.properties.getIops());
}
if (action.properties.getSize() != null) {
createVolumeType.setSize(action.properties.getSize());
}
if (action.properties.getSnapshotId() != null) {
createVolumeType.setSnapshotId(action.properties.getSnapshotId());
}
if (action.properties.getVolumeType() != null) {
createVolumeType.setVolumeType(action.properties.getVolumeType());
} else {
createVolumeType.setVolumeType("standard");
}
CreateVolumeResponseType createVolumeResponseType =
AsyncRequests.<CreateVolumeType, CreateVolumeResponseType>sendSync(
configuration, createVolumeType);
action.info.setPhysicalResourceId(createVolumeResponseType.getVolume().getVolumeId());
action.info.setCreatedEnoughToDelete(true);
action.info.setReferenceValueJson(
JsonHelper.getStringFromJsonNode(new TextNode(action.info.getPhysicalResourceId())));
return action;
}
@Override
public ResourceAction perform(ResourceAction resourceAction) throws Exception {
AWSIAMInstanceProfileResourceAction action =
(AWSIAMInstanceProfileResourceAction) resourceAction;
ServiceConfiguration configuration = Topology.lookup(Euare.class);
String instanceProfileName = action.getDefaultPhysicalResourceId();
CreateInstanceProfileType createInstanceProfileType =
MessageHelper.createMessage(
CreateInstanceProfileType.class, action.info.getEffectiveUserId());
createInstanceProfileType.setPath(action.properties.getPath());
createInstanceProfileType.setInstanceProfileName(instanceProfileName);
CreateInstanceProfileResponseType createInstanceProfileResponseType =
AsyncRequests.<CreateInstanceProfileType, CreateInstanceProfileResponseType>sendSync(
configuration, createInstanceProfileType);
String arn =
createInstanceProfileResponseType
.getCreateInstanceProfileResult()
.getInstanceProfile()
.getArn();
action.info.setPhysicalResourceId(instanceProfileName);
action.info.setCreatedEnoughToDelete(true);
action.info.setArn(JsonHelper.getStringFromJsonNode(new TextNode(arn)));
action.info.setReferenceValueJson(
JsonHelper.getStringFromJsonNode(new TextNode(action.info.getPhysicalResourceId())));
return action;
}
private static boolean volumeDeleted(
AWSEC2VolumeResourceAction action, ServiceConfiguration configuration) throws Exception {
if (!Boolean.TRUE.equals(action.info.getCreatedEnoughToDelete())) return true;
DescribeVolumesType describeVolumesType =
MessageHelper.createMessage(DescribeVolumesType.class, action.info.getEffectiveUserId());
describeVolumesType
.getFilterSet()
.add(Filter.filter("volume-id", action.info.getPhysicalResourceId()));
DescribeVolumesResponseType describeVolumesResponseType;
try {
describeVolumesResponseType = AsyncRequests.sendSync(configuration, describeVolumesType);
} catch (final Exception e) {
throw new ValidationErrorException(
"Error describing volume "
+ action.info.getPhysicalResourceId()
+ ":"
+ asWebServiceErrorMessage(e, e.getMessage()));
}
if (describeVolumesResponseType.getVolumeSet().size() == 0) {
return true; // already deleted
}
if ("deleted".equals(describeVolumesResponseType.getVolumeSet().get(0).getStatus())) {
return true;
}
return false;
}
private void disassociateRouteTable(ServiceConfiguration configuration, String associationId)
throws Exception {
DisassociateRouteTableType disassociateRouteTableType =
MessageHelper.createMessage(DisassociateRouteTableType.class, info.getEffectiveUserId());
disassociateRouteTableType.setAssociationId(associationId);
AsyncRequests.<DisassociateRouteTableType, DisassociateRouteTableResponseType>sendSync(
configuration, disassociateRouteTableType);
}
public static void handleOrphan(Cluster cluster, ClusterAddressInfo address) {
Integer orphanCount = 1;
orphanCount = orphans.putIfAbsent(address, orphanCount);
orphanCount = (orphanCount == null) ? 1 : orphanCount;
orphans.put(address, orphanCount + 1);
EventRecord.caller(
ClusterState.class,
EventType.ADDRESS_STATE,
"Updated orphaned public ip address: "
+ LogUtil.dumpObject(address)
+ " count="
+ orphanCount)
.debug();
if (orphanCount > AddressingConfiguration.getInstance().getMaxKillOrphans()) {
EventRecord.caller(
ClusterState.class,
EventType.ADDRESS_STATE,
"Unassigning orphaned public ip address: "
+ LogUtil.dumpObject(address)
+ " count="
+ orphanCount)
.warn();
try {
final Address addr = Addresses.getInstance().lookup(address.getAddress());
if (addr.isPending()) {
try {
addr.clearPending();
} catch (Exception ex) {
}
}
try {
if (addr.isAssigned() && "0.0.0.0".equals(address.getInstanceIp())) {
addr.unassign().clearPending();
if (addr.isSystemOwned()) {
addr.release();
}
} else if (addr.isAssigned() && !"0.0.0.0".equals(address.getInstanceIp())) {
AsyncRequests.newRequest(new UnassignAddressCallback(address))
.sendSync(cluster.getConfiguration());
if (addr.isSystemOwned()) {
addr.release();
}
} else if (!addr.isAssigned() && addr.isAllocated() && addr.isSystemOwned()) {
addr.release();
}
} catch (ExecutionException ex) {
if (!addr.isAssigned() && addr.isAllocated() && addr.isSystemOwned()) {
addr.release();
}
}
} catch (InterruptedException ex) {
Exceptions.maybeInterrupted(ex);
} catch (NoSuchElementException ex) {
} finally {
orphans.remove(address);
}
}
}
private String associateRouteTable(
ServiceConfiguration configuration, String subnetId, String routeTableId) throws Exception {
AssociateRouteTableType associateRouteTableType =
MessageHelper.createMessage(AssociateRouteTableType.class, info.getEffectiveUserId());
associateRouteTableType.setRouteTableId(routeTableId);
associateRouteTableType.setSubnetId(subnetId);
AssociateRouteTableResponseType associateRouteTableResponseType =
AsyncRequests.<AssociateRouteTableType, AssociateRouteTableResponseType>sendSync(
configuration, associateRouteTableType);
return associateRouteTableResponseType.getAssociationId();
}
@Override
public ResourceAction perform(ResourceAction resourceAction) throws Exception {
AWSEC2VolumeResourceAction action = (AWSEC2VolumeResourceAction) resourceAction;
ServiceConfiguration configuration = Topology.lookup(Compute.class);
if (volumeDeleted(action, configuration)) return action;
DeleteVolumeType deleteVolumeType =
MessageHelper.createMessage(DeleteVolumeType.class, action.info.getEffectiveUserId());
deleteVolumeType.setVolumeId(action.info.getPhysicalResourceId());
AsyncRequests.<DeleteVolumeType, DeleteVolumeResponseType>sendSync(
configuration, deleteVolumeType);
return action;
}
private void checkSubnetExists(ServiceConfiguration configuration) throws Exception {
DescribeSubnetsType describeSubnetsType =
MessageHelper.createMessage(DescribeSubnetsType.class, info.getEffectiveUserId());
describeSubnetsType.getFilterSet().add(Filter.filter("subnet-id", properties.getSubnetId()));
DescribeSubnetsResponseType describeSubnetsResponseType =
AsyncRequests.sendSync(configuration, describeSubnetsType);
if (describeSubnetsResponseType.getSubnetSet() == null
|| describeSubnetsResponseType.getSubnetSet().getItem() == null
|| describeSubnetsResponseType.getSubnetSet().getItem().isEmpty()) {
throw new ValidationErrorException("No such subnet with id '" + properties.getSubnetId());
}
}
private boolean subnetExistsForDelete(ServiceConfiguration configuration) throws Exception {
DescribeSubnetsType describeSubnetsType =
MessageHelper.createMessage(DescribeSubnetsType.class, info.getEffectiveUserId());
describeSubnetsType.getFilterSet().add(Filter.filter("subnet-id", properties.getSubnetId()));
DescribeSubnetsResponseType describeSubnetsResponseType =
AsyncRequests.sendSync(configuration, describeSubnetsType);
if (describeSubnetsResponseType.getSubnetSet() == null
|| describeSubnetsResponseType.getSubnetSet().getItem() == null
|| describeSubnetsResponseType.getSubnetSet().getItem().isEmpty()) {
return false;
}
return true;
}
@Override
public void delete() throws Exception {
if (info.getPhysicalResourceId() == null) return;
ServiceConfiguration configuration = Topology.lookup(LoadBalancing.class);
// if lb gone, done
DescribeLoadBalancersType describeLoadBalancersType = new DescribeLoadBalancersType();
LoadBalancerNames loadBalancerNames = new LoadBalancerNames();
ArrayList<String> member = Lists.newArrayList(info.getPhysicalResourceId());
loadBalancerNames.setMember(member);
describeLoadBalancersType.setLoadBalancerNames(loadBalancerNames);
describeLoadBalancersType.setEffectiveUserId(info.getEffectiveUserId());
DescribeLoadBalancersResponseType describeLoadBalancersResponseType =
AsyncRequests.<DescribeLoadBalancersType, DescribeLoadBalancersResponseType>sendSync(
configuration, describeLoadBalancersType);
if (describeLoadBalancersResponseType != null
&& describeLoadBalancersResponseType.getDescribeLoadBalancersResult() != null
&& describeLoadBalancersResponseType
.getDescribeLoadBalancersResult()
.getLoadBalancerDescriptions()
!= null
&& describeLoadBalancersResponseType
.getDescribeLoadBalancersResult()
.getLoadBalancerDescriptions()
.getMember()
!= null
&& describeLoadBalancersResponseType
.getDescribeLoadBalancersResult()
.getLoadBalancerDescriptions()
.getMember()
.size()
> 0) {
return;
}
DeleteLoadBalancerType deleteLoadBalancerType = new DeleteLoadBalancerType();
deleteLoadBalancerType.setLoadBalancerName(info.getPhysicalResourceId());
deleteLoadBalancerType.setEffectiveUserId(info.getEffectiveUserId());
AsyncRequests.<DeleteLoadBalancerType, DeleteLoadBalancerResponseType>sendSync(
configuration, deleteLoadBalancerType);
}
private String replaceAssociation(
ServiceConfiguration configuration, String oldAssociationId, String routeTableId)
throws Exception {
ReplaceRouteTableAssociationType replaceRouteTableAssociationType =
MessageHelper.createMessage(
ReplaceRouteTableAssociationType.class, info.getEffectiveUserId());
replaceRouteTableAssociationType.setRouteTableId(routeTableId);
replaceRouteTableAssociationType.setAssociationId(oldAssociationId);
ReplaceRouteTableAssociationResponseType replaceRouteTableAssociationResponseType =
AsyncRequests
.<ReplaceRouteTableAssociationType, ReplaceRouteTableAssociationResponseType>sendSync(
configuration, replaceRouteTableAssociationType);
return replaceRouteTableAssociationResponseType.getNewAssociationId();
}
@Override
public ResourceAction perform(ResourceAction resourceAction) throws Exception {
AWSEC2VolumeResourceAction action = (AWSEC2VolumeResourceAction) resourceAction;
ServiceConfiguration configuration = Topology.lookup(Compute.class);
if (action.properties.getAutoEnableIO() != null) {
ModifyVolumeAttributeType modifyVolumeAttributeTypeType =
MessageHelper.createMessage(
ModifyVolumeAttributeType.class, action.info.getEffectiveUserId());
modifyVolumeAttributeTypeType.setVolumeId(action.info.getPhysicalResourceId());
modifyVolumeAttributeTypeType.setAutoEnableIO(action.properties.getAutoEnableIO());
AsyncRequests.sendSync(configuration, modifyVolumeAttributeTypeType);
}
return action;
}
@Override
public void fireException(Throwable e) {
LOG.debug(e);
Logs.extreme().error(e, e);
LOG.debug(
"Trying to remove invalid volume attachment "
+ this.getRequest().getVolumeId()
+ " from instance "
+ this.getRequest().getInstanceId());
try {
VmInstance vm = VmInstances.lookup(this.getRequest().getInstanceId());
Partition partition = vm.lookupPartition();
ServiceConfiguration sc = Topology.lookup(Storage.class, partition);
/** clean up SC session state * */
try {
LOG.debug(
"Sending detach after async failure in attach volume: "
+ this.getRequest().getVolumeId()
+ " sc="
+ sc);
AsyncRequests.sendSync(sc, new DetachStorageVolumeType(this.getRequest().getVolumeId()));
} catch (Exception ex) {
LOG.error(ex);
Logs.extreme().error(ex, ex);
}
/** clean up internal attachment state * */
final Function<String, VmInstance> removeVolAttachment =
new Function<String, VmInstance>() {
public VmInstance apply(final String input) {
VmInstance vm = VmInstances.lookup(input);
vm.removeVolumeAttachment(VolumeAttachCallback.this.getRequest().getVolumeId());
return vm;
}
};
Entities.asTransaction(VmInstance.class, removeVolAttachment)
.apply(this.getRequest().getInstanceId());
LOG.debug(
"Removed failed attachment: "
+ this.getRequest().getVolumeId()
+ " -> "
+ vm.getInstanceId());
} catch (Exception e1) {
LOG.error(e1);
Logs.extreme().error(e1, e1);
}
}
@Override
public ResourceAction perform(ResourceAction resourceAction) throws Exception {
AWSIAMPolicyResourceAction action = (AWSIAMPolicyResourceAction) resourceAction;
ServiceConfiguration configuration = Topology.lookup(Euare.class);
if (action.properties.getGroups() != null) {
for (String groupName : action.properties.getGroups()) {
PutGroupPolicyType putGroupPolicyType =
MessageHelper.createMessage(
PutGroupPolicyType.class, action.info.getEffectiveUserId());
putGroupPolicyType.setGroupName(groupName);
putGroupPolicyType.setPolicyName(action.properties.getPolicyName());
putGroupPolicyType.setPolicyDocument(action.properties.getPolicyDocument().toString());
AsyncRequests.<PutGroupPolicyType, PutGroupPolicyResponseType>sendSync(
configuration, putGroupPolicyType);
}
}
return action;
}
@Override
public ResourceAction perform(ResourceAction resourceAction) throws Exception {
AWSIAMInstanceProfileResourceAction action =
(AWSIAMInstanceProfileResourceAction) resourceAction;
ServiceConfiguration configuration = Topology.lookup(Euare.class);
if (!Boolean.TRUE.equals(action.info.getCreatedEnoughToDelete())) return action;
if (!IAMHelper.instanceProfileExists(
configuration, action.info.getPhysicalResourceId(), action.info.getEffectiveUserId()))
return action;
// we can delete the instance profile without detaching the role
DeleteInstanceProfileType deleteInstanceProfileType =
MessageHelper.createMessage(
DeleteInstanceProfileType.class, action.info.getEffectiveUserId());
deleteInstanceProfileType.setInstanceProfileName(action.info.getPhysicalResourceId());
AsyncRequests.<DeleteInstanceProfileType, DeleteInstanceProfileResponseType>sendSync(
configuration, deleteInstanceProfileType);
return action;
}
@Override
public ResourceAction perform(ResourceAction resourceAction) throws Exception {
AWSIAMInstanceProfileResourceAction action =
(AWSIAMInstanceProfileResourceAction) resourceAction;
ServiceConfiguration configuration = Topology.lookup(Euare.class);
if (action.properties.getRoles() != null) {
for (String roleName : action.properties.getRoles()) {
AddRoleToInstanceProfileType addRoleToInstanceProfileType =
MessageHelper.createMessage(
AddRoleToInstanceProfileType.class, action.info.getEffectiveUserId());
addRoleToInstanceProfileType.setInstanceProfileName(
action.info.getPhysicalResourceId());
addRoleToInstanceProfileType.setRoleName(roleName);
AsyncRequests
.<AddRoleToInstanceProfileType, AddRoleToInstanceProfileResponseType>sendSync(
configuration, addRoleToInstanceProfileType);
}
}
return action;
}
private boolean associationIdExistsForDelete(ServiceConfiguration configuration)
throws Exception {
DescribeRouteTablesType describeRouteTablesType =
MessageHelper.createMessage(DescribeRouteTablesType.class, info.getEffectiveUserId());
ArrayList<Filter> filterSet = Lists.newArrayList();
;
Filter filter = new Filter();
filter.setName("association.route-table-association-id");
filter.setValueSet(Lists.<String>newArrayList(info.getPhysicalResourceId()));
filterSet.add(filter);
describeRouteTablesType.setFilterSet(filterSet);
DescribeRouteTablesResponseType describeRouteTablesResponseType =
AsyncRequests.<DescribeRouteTablesType, DescribeRouteTablesResponseType>sendSync(
configuration, describeRouteTablesType);
if (describeRouteTablesResponseType.getRouteTableSet() == null
|| describeRouteTablesResponseType.getRouteTableSet().getItem() == null
|| describeRouteTablesResponseType.getRouteTableSet().getItem().isEmpty()) {
return false;
}
return true;
}
static Map<String, StorageVolume> updateVolumesInPartition(final String partition) {
final Map<String, StorageVolume> idStorageVolumeMap = Maps.newHashMap();
final ServiceConfiguration scConfig =
Topology.lookup(Storage.class, Partitions.lookupByName(partition));
try {
final DescribeStorageVolumesResponseType volState =
AsyncRequests.sendSync(scConfig, new DescribeStorageVolumesType());
for (final StorageVolume vol : volState.getVolumeSet()) {
LOG.trace(
"Volume states: "
+ vol.getVolumeId()
+ " "
+ vol.getStatus()
+ " "
+ vol.getActualDeviceName());
idStorageVolumeMap.put(vol.getVolumeId(), vol);
}
} catch (final Exception ex) {
LOG.error(ex);
Logs.extreme().error(ex, ex);
}
return idStorageVolumeMap;
}
private void clearState() {
EventRecord.here(
AssignAddressCallback.class,
EventType.ADDRESS_ASSIGNING,
Transition.assigning.toString(),
"FAILED",
this.address.toString())
.debug();
if (this.address.isPending()) {
try {
this.address.clearPending();
} catch (Exception ex) {
}
}
if (this.address.isSystemOwned()) {
Addresses.release(this.address);
} else if (this.address.isAssigned() && this.vm != null) {
AddressingDispatcher.dispatch(
AsyncRequests.newRequest(this.address.unassign().getCallback()), vm.getPartition());
} else if (this.address.isAssigned() && this.vm == null) {
this.address.unassign().clearPending();
}
}
@Override
public ResourceAction perform(ResourceAction resourceAction) throws Exception {
AWSEC2VolumeResourceAction action = (AWSEC2VolumeResourceAction) resourceAction;
ServiceConfiguration configuration = Topology.lookup(Compute.class);
if (volumeDeleted(action, configuration)) return action;
if (!("Snapshot".equals(action.info.getDeletionPolicy()))) return action;
CreateSnapshotType createSnapshotType =
MessageHelper.createMessage(CreateSnapshotType.class, action.info.getEffectiveUserId());
createSnapshotType.setVolumeId(action.info.getPhysicalResourceId());
CreateSnapshotResponseType createSnapshotResponseType =
AsyncRequests.<CreateSnapshotType, CreateSnapshotResponseType>sendSync(
configuration, createSnapshotType);
if (createSnapshotResponseType.getSnapshot() == null
|| createSnapshotResponseType.getSnapshot().getSnapshotId() == null) {
throw new ResourceFailureException(
"Unable to create snapshot on delete for volume "
+ action.info.getPhysicalResourceId());
} else {
action.info.setSnapshotIdForDelete(
JsonHelper.getStringFromJsonNode(
new TextNode(createSnapshotResponseType.getSnapshot().getSnapshotId())));
}
return action;
}
@Override
public ResourceAction perform(ResourceAction resourceAction) throws Exception {
AWSIAMInstanceProfileResourceAction action =
(AWSIAMInstanceProfileResourceAction) resourceAction;
ServiceConfiguration configuration = Topology.lookup(Euare.class);
if (action.properties.getRoles() != null) {
if (action.properties.getRoles().size() > 1)
throw new ValidationErrorException("Roles has too many elements. The limit is 1.");
if (action.properties.getRoles().size() == 0)
throw new ValidationErrorException("Property Roles can not be empty.");
for (String roleName : action.properties.getRoles()) {
AddRoleToInstanceProfileType addRoleToInstanceProfileType =
MessageHelper.createMessage(
AddRoleToInstanceProfileType.class, action.info.getEffectiveUserId());
addRoleToInstanceProfileType.setInstanceProfileName(
action.info.getPhysicalResourceId());
addRoleToInstanceProfileType.setRoleName(roleName);
AsyncRequests
.<AddRoleToInstanceProfileType, AddRoleToInstanceProfileResponseType>sendSync(
configuration, addRoleToInstanceProfileType);
}
}
return action;
}
@Override
public ResourceAction perform(ResourceAction resourceAction) throws Exception {
AWSIAMInstanceProfileResourceAction action =
(AWSIAMInstanceProfileResourceAction) resourceAction;
ServiceConfiguration configuration = Topology.lookup(Euare.class);
if (action.info.getPhysicalResourceId() == null) return action;
// if no instance profile, bye...
boolean seenAllInstanceProfiles = false;
boolean foundInstanceProfile = false;
String instanceProfileMarker = null;
while (!seenAllInstanceProfiles && !foundInstanceProfile) {
ListInstanceProfilesType listInstanceProfilesType =
MessageHelper.createMessage(
ListInstanceProfilesType.class, action.info.getEffectiveUserId());
if (instanceProfileMarker != null) {
listInstanceProfilesType.setMarker(instanceProfileMarker);
}
ListInstanceProfilesResponseType listInstanceProfilesResponseType =
AsyncRequests.<ListInstanceProfilesType, ListInstanceProfilesResponseType>sendSync(
configuration, listInstanceProfilesType);
if (listInstanceProfilesResponseType.getListInstanceProfilesResult().getIsTruncated()
== Boolean.TRUE) {
instanceProfileMarker =
listInstanceProfilesResponseType.getListInstanceProfilesResult().getMarker();
} else {
seenAllInstanceProfiles = true;
}
if (listInstanceProfilesResponseType.getListInstanceProfilesResult().getInstanceProfiles()
!= null
&& listInstanceProfilesResponseType
.getListInstanceProfilesResult()
.getInstanceProfiles()
.getMember()
!= null) {
for (InstanceProfileType instanceProfileType :
listInstanceProfilesResponseType
.getListInstanceProfilesResult()
.getInstanceProfiles()
.getMember()) {
if (instanceProfileType
.getInstanceProfileName()
.equals(action.info.getPhysicalResourceId())) {
foundInstanceProfile = true;
break;
}
}
}
}
// we can delete the instance profile without detaching the role
if (!foundInstanceProfile) return action;
DeleteInstanceProfileType deleteInstanceProfileType =
MessageHelper.createMessage(
DeleteInstanceProfileType.class, action.info.getEffectiveUserId());
deleteInstanceProfileType.setInstanceProfileName(action.info.getPhysicalResourceId());
AsyncRequests.<DeleteInstanceProfileType, DeleteInstanceProfileResponseType>sendSync(
configuration, deleteInstanceProfileType);
return action;
}
public DetachVolumeResponseType detach(DetachVolumeType request) throws EucalyptusCloudException {
DetachVolumeResponseType reply = (DetachVolumeResponseType) request.getReply();
Context ctx = Contexts.lookup();
Volume vol;
try {
vol = Volumes.lookup(ctx.getUserFullName().asAccountFullName(), request.getVolumeId());
} catch (Exception ex1) {
throw new EucalyptusCloudException("Volume does not exist: " + request.getVolumeId());
}
if (!RestrictedTypes.filterPrivileged().apply(vol)) {
throw new EucalyptusCloudException(
"Not authorized to detach volume "
+ request.getVolumeId()
+ " by "
+ ctx.getUser().getName());
}
VmInstance vm = null;
AttachedVolume volume = null;
try {
VmVolumeAttachment vmVolAttach = VmInstances.lookupVolumeAttachment(request.getVolumeId());
volume = VmVolumeAttachment.asAttachedVolume(vmVolAttach.getVmInstance()).apply(vmVolAttach);
vm = vmVolAttach.getVmInstance();
} catch (NoSuchElementException ex) {
/** no such attachment * */
}
if (volume == null) {
throw new EucalyptusCloudException("Volume is not attached: " + request.getVolumeId());
}
if (!RestrictedTypes.filterPrivileged().apply(vm)) {
throw new EucalyptusCloudException(
"Not authorized to detach volume from instance "
+ request.getInstanceId()
+ " by "
+ ctx.getUser().getName());
}
if (!vm.getInstanceId().equals(request.getInstanceId())
&& request.getInstanceId() != null
&& !request.getInstanceId().equals("")) {
throw new EucalyptusCloudException(
"Volume is not attached to instance: " + request.getInstanceId());
}
if (request.getDevice() != null
&& !request.getDevice().equals("")
&& !volume.getDevice().equals(request.getDevice())) {
throw new EucalyptusCloudException(
"Volume is not attached to device: " + request.getDevice());
}
Cluster cluster = null;
ServiceConfiguration ccConfig = null;
try {
ccConfig = Topology.lookup(ClusterController.class, vm.lookupPartition());
cluster = Clusters.lookup(ccConfig);
} catch (NoSuchElementException e) {
LOG.debug(e, e);
throw new EucalyptusCloudException(
"Cluster does not exist in partition: " + vm.getPartition());
}
ServiceConfiguration scVm;
try {
scVm = Topology.lookup(Storage.class, vm.lookupPartition());
} catch (Exception ex) {
LOG.error(ex, ex);
throw new EucalyptusCloudException(
"Failed to lookup SC for partition: " + vm.getPartition(), ex);
}
request.setVolumeId(volume.getVolumeId());
request.setRemoteDevice(volume.getRemoteDevice());
request.setDevice(volume.getDevice().replaceAll("unknown,requested:", ""));
request.setInstanceId(vm.getInstanceId());
VolumeDetachCallback ncDetach = new VolumeDetachCallback(request);
try {
AsyncRequests.sendSync(scVm, new DetachStorageVolumeType(volume.getVolumeId()));
} catch (Exception e) {
LOG.debug(e);
Logs.extreme().debug(e, e);
// GRZE: attach is idempotent, failure here is ok. throw new EucalyptusCloudException(
// e.getMessage( ) );
}
AsyncRequests.newRequest(ncDetach).dispatch(cluster.getConfiguration());
EventRecord.here(VolumeManager.class, EventClass.VOLUME, EventType.VOLUME_DETACH)
.withDetails(vm.getOwner().toString(), volume.getVolumeId(), "instance", vm.getInstanceId())
.withDetails("cluster", ccConfig.getFullName().toString())
.info();
volume.setStatus("detaching");
reply.setDetachedVolume(volume);
return reply;
}
@Override
public ResourceAction perform(
ResourceAction oldResourceAction, ResourceAction newResourceAction) throws Exception {
AWSEC2VolumeResourceAction oldAction = (AWSEC2VolumeResourceAction) oldResourceAction;
AWSEC2VolumeResourceAction newAction = (AWSEC2VolumeResourceAction) newResourceAction;
ServiceConfiguration configuration = Topology.lookup(Compute.class);
DescribeTagsType describeTagsType =
MessageHelper.createMessage(
DescribeTagsType.class, newAction.info.getEffectiveUserId());
describeTagsType.setFilterSet(
Lists.newArrayList(
Filter.filter("resource-id", newAction.info.getPhysicalResourceId())));
DescribeTagsResponseType describeTagsResponseType =
AsyncRequests.sendSync(configuration, describeTagsType);
Set<EC2Tag> existingTags = Sets.newLinkedHashSet();
if (describeTagsResponseType != null && describeTagsResponseType.getTagSet() != null) {
for (TagInfo tagInfo : describeTagsResponseType.getTagSet()) {
EC2Tag tag = new EC2Tag();
tag.setKey(tagInfo.getKey());
tag.setValue(tagInfo.getValue());
existingTags.add(tag);
}
}
Set<EC2Tag> newTags = Sets.newLinkedHashSet();
if (newAction.properties.getTags() != null) {
newTags.addAll(newAction.properties.getTags());
}
List<EC2Tag> newStackTags = TagHelper.getEC2StackTags(newAction.getStackEntity());
if (newStackTags != null) {
newTags.addAll(newStackTags);
}
TagHelper.checkReservedEC2TemplateTags(newTags);
// add only 'new' tags
Set<EC2Tag> onlyNewTags = Sets.difference(newTags, existingTags);
if (!onlyNewTags.isEmpty()) {
CreateTagsType createTagsType =
MessageHelper.createMessage(
CreateTagsType.class, newAction.info.getEffectiveUserId());
createTagsType.setResourcesSet(
Lists.newArrayList(newAction.info.getPhysicalResourceId()));
createTagsType.setTagSet(EC2Helper.createTagSet(onlyNewTags));
AsyncRequests.<CreateTagsType, CreateTagsResponseType>sendSync(
configuration, createTagsType);
}
// Get old tags...
Set<EC2Tag> oldTags = Sets.newLinkedHashSet();
if (oldAction.properties.getTags() != null) {
oldTags.addAll(oldAction.properties.getTags());
}
List<EC2Tag> oldStackTags = TagHelper.getEC2StackTags(oldAction.getStackEntity());
if (oldStackTags != null) {
oldTags.addAll(oldStackTags);
}
// remove only the old tags that are not new and that exist
Set<EC2Tag> tagsToRemove =
Sets.intersection(oldTags, Sets.difference(existingTags, newTags));
if (!tagsToRemove.isEmpty()) {
DeleteTagsType deleteTagsType =
MessageHelper.createMessage(
DeleteTagsType.class, newAction.info.getEffectiveUserId());
deleteTagsType.setResourcesSet(
Lists.newArrayList(newAction.info.getPhysicalResourceId()));
deleteTagsType.setTagSet(EC2Helper.deleteTagSet(tagsToRemove));
AsyncRequests.<DeleteTagsType, DeleteTagsResponseType>sendSync(
configuration, deleteTagsType);
}
return newAction;
}
@Override
public void create(int stepNum) throws Exception {
ServiceConfiguration configuration = Topology.lookup(LoadBalancing.class);
switch (stepNum) {
case 0: // create load balancer
CreateLoadBalancerType createLoadBalancerType = new CreateLoadBalancerType();
createLoadBalancerType.setEffectiveUserId(info.getEffectiveUserId());
if (properties.getLoadBalancerName() == null) {
// The name here is a little weird. It needs to be no more than 32 characters
createLoadBalancerType.setLoadBalancerName(getDefaultPhysicalResourceId(32));
} else {
createLoadBalancerType.setLoadBalancerName(properties.getLoadBalancerName());
}
if (properties.getAvailabilityZones() != null) {
AvailabilityZones availabilityZones = new AvailabilityZones();
ArrayList<String> member = Lists.newArrayList(properties.getAvailabilityZones());
availabilityZones.setMember(member);
createLoadBalancerType.setAvailabilityZones(availabilityZones);
}
if (properties.getListeners() != null) {
Listeners listeners = new Listeners();
ArrayList<Listener> member = Lists.newArrayList();
for (ElasticLoadBalancingListener elasticLoadBalancingListener :
properties.getListeners()) {
Listener listener = new Listener();
listener.setInstancePort(elasticLoadBalancingListener.getInstancePort());
listener.setInstanceProtocol(elasticLoadBalancingListener.getInstanceProtocol());
listener.setLoadBalancerPort(elasticLoadBalancingListener.getLoadBalancerPort());
listener.setProtocol(elasticLoadBalancingListener.getProtocol());
listener.setSSLCertificateId(elasticLoadBalancingListener.getSslCertificateId());
// TO set the policies, look at the next step
member.add(listener);
}
listeners.setMember(member);
createLoadBalancerType.setListeners(listeners);
}
createLoadBalancerType.setScheme(properties.getScheme());
if (properties.getSecurityGroups() != null) {
SecurityGroups securityGroups = new SecurityGroups();
ArrayList<String> member = Lists.newArrayList(properties.getSecurityGroups());
securityGroups.setMember(member);
createLoadBalancerType.setSecurityGroups(securityGroups);
}
if (properties.getSubnets() != null) {
Subnets subnets = new Subnets();
ArrayList<String> member = Lists.newArrayList(properties.getSubnets());
subnets.setMember(member);
createLoadBalancerType.setSubnets(subnets);
}
CreateLoadBalancerResponseType createLoadBalancerResponseType =
AsyncRequests.<CreateLoadBalancerType, CreateLoadBalancerResponseType>sendSync(
configuration, createLoadBalancerType);
info.setPhysicalResourceId(createLoadBalancerType.getLoadBalancerName());
info.setDnsName(
JsonHelper.getStringFromJsonNode(
new TextNode(
createLoadBalancerResponseType.getCreateLoadBalancerResult().getDnsName())));
info.setReferenceValueJson(
JsonHelper.getStringFromJsonNode(new TextNode(info.getPhysicalResourceId())));
break;
case 1: // add instances to load balancer
if (properties.getInstances() != null) {
RegisterInstancesWithLoadBalancerType registerInstancesWithLoadBalancerType =
new RegisterInstancesWithLoadBalancerType();
registerInstancesWithLoadBalancerType.setLoadBalancerName(info.getPhysicalResourceId());
Instances instances = new Instances();
ArrayList<Instance> member = Lists.newArrayList();
for (String instanceId : properties.getInstances()) {
Instance instance = new Instance();
instance.setInstanceId(instanceId);
member.add(instance);
}
instances.setMember(member);
registerInstancesWithLoadBalancerType.setInstances(instances);
registerInstancesWithLoadBalancerType.setEffectiveUserId(info.getEffectiveUserId());
AsyncRequests
.<RegisterInstancesWithLoadBalancerType,
RegisterInstancesWithLoadBalancerResponseType>
sendSync(configuration, registerInstancesWithLoadBalancerType);
}
break;
case 2: // add health check to load balancer
if (properties.getHealthCheck() != null) {
ConfigureHealthCheckType configureHealthCheckType = new ConfigureHealthCheckType();
configureHealthCheckType.setLoadBalancerName(info.getPhysicalResourceId());
HealthCheck healthCheck = new HealthCheck();
healthCheck.setHealthyThreshold(properties.getHealthCheck().getHealthyThreshold());
healthCheck.setInterval(properties.getHealthCheck().getInterval());
healthCheck.setTarget(properties.getHealthCheck().getTarget());
healthCheck.setTimeout(properties.getHealthCheck().getTimeout());
healthCheck.setUnhealthyThreshold(properties.getHealthCheck().getUnhealthyThreshold());
configureHealthCheckType.setHealthCheck(healthCheck);
configureHealthCheckType.setEffectiveUserId(info.getEffectiveUserId());
AsyncRequests.<ConfigureHealthCheckType, ConfigureHealthCheckResponseType>sendSync(
configuration, configureHealthCheckType);
}
break;
case 3: // add policies to load balancer
if (properties.getPolicies() != null) {
for (ElasticLoadBalancingPolicyType elasticLoadBalancingPropertyType :
properties.getPolicies()) {
CreateLoadBalancerPolicyType createLoadBalancerPolicyType =
new CreateLoadBalancerPolicyType();
createLoadBalancerPolicyType.setLoadBalancerName(info.getPhysicalResourceId());
if (elasticLoadBalancingPropertyType.getAttributes() != null) {
PolicyAttributes policyAttributes = new PolicyAttributes();
ArrayList<PolicyAttribute> member = Lists.newArrayList();
for (ElasticLoadBalancingPolicyTypeAttribute elasticLoadBalancingPolicyTypeAttribute :
elasticLoadBalancingPropertyType.getAttributes()) {
PolicyAttribute policyAttribute = new PolicyAttribute();
policyAttribute.setAttributeName(elasticLoadBalancingPolicyTypeAttribute.getName());
policyAttribute.setAttributeValue(
elasticLoadBalancingPolicyTypeAttribute.getValue());
member.add(policyAttribute);
}
policyAttributes.setMember(member);
createLoadBalancerPolicyType.setPolicyAttributes(policyAttributes);
}
createLoadBalancerPolicyType.setPolicyName(
elasticLoadBalancingPropertyType.getPolicyName());
createLoadBalancerPolicyType.setPolicyTypeName(
elasticLoadBalancingPropertyType.getPolicyType());
createLoadBalancerPolicyType.setEffectiveUserId(info.getEffectiveUserId());
// NOTE: Cloudformation says that policies have two more fields, "InstanceIds" (which
// bind to the back end, but which we don't currently support), and
// "LoadBalancerPorts" which seems redundant since Listeners have PolicyNames associated
// with them (the docs say load balancer ports are only associated with
// some policy types). The first one we don't support and the second we don't know what
// it means in a non-circular way (TODO: figure that out) so we don't
// support either currently
AsyncRequests
.<CreateLoadBalancerPolicyType, CreateLoadBalancerPolicyResponseType>sendSync(
configuration, createLoadBalancerPolicyType);
}
}
break;
case 4: // add load balancer policies to listeners
if (properties.getListeners() != null) {
for (ElasticLoadBalancingListener elasticLoadBalancingListener :
properties.getListeners()) {
if (elasticLoadBalancingListener.getPolicyNames() != null) {
SetLoadBalancerPoliciesOfListenerType setLoadBalancerPoliciesOfListenerType =
new SetLoadBalancerPoliciesOfListenerType();
setLoadBalancerPoliciesOfListenerType.setLoadBalancerName(
info.getPhysicalResourceId());
setLoadBalancerPoliciesOfListenerType.setLoadBalancerPort(
elasticLoadBalancingListener.getLoadBalancerPort());
PolicyNames policyNames = new PolicyNames();
ArrayList<String> member =
Lists.newArrayList(elasticLoadBalancingListener.getPolicyNames());
policyNames.setMember(member);
setLoadBalancerPoliciesOfListenerType.setPolicyNames(policyNames);
setLoadBalancerPoliciesOfListenerType.setEffectiveUserId(info.getEffectiveUserId());
AsyncRequests
.<SetLoadBalancerPoliciesOfListenerType,
SetLoadBalancerPoliciesOfListenerResponseType>
sendSync(configuration, setLoadBalancerPoliciesOfListenerType);
}
}
}
break;
case 5: // add app stickiness policy load balancer
if (properties.getAppCookieStickinessPolicy() != null) {
CreateAppCookieStickinessPolicyType createAppCookieStickinessPolicyType =
new CreateAppCookieStickinessPolicyType();
createAppCookieStickinessPolicyType.setPolicyName(
properties.getAppCookieStickinessPolicy().getPolicyName());
createAppCookieStickinessPolicyType.setLoadBalancerName(info.getPhysicalResourceId());
createAppCookieStickinessPolicyType.setCookieName(
properties.getAppCookieStickinessPolicy().getCookieName());
createAppCookieStickinessPolicyType.setEffectiveUserId(info.getEffectiveUserId());
AsyncRequests
.<CreateAppCookieStickinessPolicyType, CreateAppCookieStickinessPolicyResponseType>
sendSync(configuration, createAppCookieStickinessPolicyType);
}
break;
case 6: // add lb stickiness policy load balancer
if (properties.getLbCookieStickinessPolicy() != null) {
CreateLBCookieStickinessPolicyType createLBCookieStickinessPolicyType =
new CreateLBCookieStickinessPolicyType();
createLBCookieStickinessPolicyType.setPolicyName(
properties.getLbCookieStickinessPolicy().getPolicyName());
createLBCookieStickinessPolicyType.setLoadBalancerName(info.getPhysicalResourceId());
createLBCookieStickinessPolicyType.setCookieExpirationPeriod(
properties.getLbCookieStickinessPolicy().getCookieExpirationPeriod());
createLBCookieStickinessPolicyType.setEffectiveUserId(info.getEffectiveUserId());
AsyncRequests
.<CreateLBCookieStickinessPolicyType, CreateLBCookieStickinessPolicyResponseType>
sendSync(configuration, createLBCookieStickinessPolicyType);
}
break;
case 7: // placeholder for "AccessLoggingPolicy", "ConnectionDrainingPolicy", "CrossZone" :
// Boolean,
break;
case 8: // describe load balancer to get attributes
DescribeLoadBalancersType describeLoadBalancersType = new DescribeLoadBalancersType();
LoadBalancerNames loadBalancerNames = new LoadBalancerNames();
ArrayList<String> member = Lists.newArrayList(info.getPhysicalResourceId());
loadBalancerNames.setMember(member);
describeLoadBalancersType.setLoadBalancerNames(loadBalancerNames);
describeLoadBalancersType.setEffectiveUserId(info.getEffectiveUserId());
DescribeLoadBalancersResponseType describeLoadBalancersResponseType =
AsyncRequests.<DescribeLoadBalancersType, DescribeLoadBalancersResponseType>sendSync(
configuration, describeLoadBalancersType);
if (describeLoadBalancersResponseType != null
&& describeLoadBalancersResponseType.getDescribeLoadBalancersResult() != null
&& describeLoadBalancersResponseType
.getDescribeLoadBalancersResult()
.getLoadBalancerDescriptions()
!= null
&& describeLoadBalancersResponseType
.getDescribeLoadBalancersResult()
.getLoadBalancerDescriptions()
.getMember()
!= null
&& describeLoadBalancersResponseType
.getDescribeLoadBalancersResult()
.getLoadBalancerDescriptions()
.getMember()
.size()
> 0) {
LoadBalancerDescription loadBalancerDescription =
describeLoadBalancersResponseType
.getDescribeLoadBalancersResult()
.getLoadBalancerDescriptions()
.getMember()
.get(0);
String canonicalHostedZoneName = loadBalancerDescription.getCanonicalHostedZoneName();
String canonicalHostedZoneNameId = loadBalancerDescription.getCanonicalHostedZoneNameID();
String sourceSecurityGroupGroupName =
loadBalancerDescription.getSourceSecurityGroup().getGroupName();
String sourceSecurityGroupGroupOwnerAlias =
loadBalancerDescription.getSourceSecurityGroup().getOwnerAlias();
if ("internal".equals(loadBalancerDescription.getScheme())) {
canonicalHostedZoneName = loadBalancerDescription.getDnsName();
}
info.setReferenceValueJson(
JsonHelper.getStringFromJsonNode(new TextNode(info.getPhysicalResourceId())));
info.setSourceSecurityGroupGroupName(
JsonHelper.getStringFromJsonNode(new TextNode(sourceSecurityGroupGroupName)));
info.setSourceSecurityGroupOwnerAlias(
JsonHelper.getStringFromJsonNode(new TextNode(sourceSecurityGroupGroupOwnerAlias)));
info.setCanonicalHostedZoneNameID(
JsonHelper.getStringFromJsonNode(new TextNode(canonicalHostedZoneNameId)));
info.setCanonicalHostedZoneName(
JsonHelper.getStringFromJsonNode(new TextNode(canonicalHostedZoneName)));
}
break;
default:
throw new IllegalStateException("Invalid step " + stepNum);
}
}
