@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 {
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 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);
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 {
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;
}
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;
}
@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 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);
}
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();
}
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());
}
}
@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 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 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;
}
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 {
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;
}
@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 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 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;
}
@Override
public ResourceAction perform(ResourceAction resourceAction) throws Exception {
AWSIAMPolicyResourceAction action = (AWSIAMPolicyResourceAction) resourceAction;
ServiceConfiguration configuration = Topology.lookup(Euare.class);
if (action.info.getPhysicalResourceId() == null) return action;
// find all roles that still exist from the list and remove the policy
if (action.properties.getRoles() != null && action.properties.getRoles().size() > 0) {
List<String> realRolesToRemovePolicyFrom = Lists.newArrayList();
Set<String> passedInRoles =
action.properties.getRoles() == null
? new HashSet<String>()
: Sets.newHashSet(action.properties.getRoles());
boolean seenAllRoles = false;
String roleMarker = null;
while (!seenAllRoles) {
ListRolesType listRolesType =
MessageHelper.createMessage(ListRolesType.class, action.info.getEffectiveUserId());
if (roleMarker != null) {
listRolesType.setMarker(roleMarker);
}
ListRolesResponseType listRolesResponseType =
AsyncRequests.<ListRolesType, ListRolesResponseType>sendSync(
configuration, listRolesType);
if (listRolesResponseType.getListRolesResult().getIsTruncated() == Boolean.TRUE) {
roleMarker = listRolesResponseType.getListRolesResult().getMarker();
} else {
seenAllRoles = true;
}
if (listRolesResponseType.getListRolesResult().getRoles() != null
&& listRolesResponseType.getListRolesResult().getRoles().getMember() != null) {
for (RoleType roleType :
listRolesResponseType.getListRolesResult().getRoles().getMember()) {
if (passedInRoles.contains(roleType.getRoleName())) {
realRolesToRemovePolicyFrom.add(roleType.getRoleName());
}
}
}
}
for (String role : realRolesToRemovePolicyFrom) {
DeleteRolePolicyType deleteRolePolicyType =
MessageHelper.createMessage(
DeleteRolePolicyType.class, action.info.getEffectiveUserId());
deleteRolePolicyType.setRoleName(role);
deleteRolePolicyType.setPolicyName(action.properties.getPolicyName());
AsyncRequests.<DeleteRolePolicyType, DeleteRolePolicyResponseType>sendSync(
configuration, deleteRolePolicyType);
}
}
// find all users that still exist from the list and remove the policy
if (action.properties.getUsers() != null && action.properties.getUsers().size() > 0) {
List<String> realUsersToRemovePolicyFrom = Lists.newArrayList();
Set<String> passedInUsers =
action.properties.getUsers() == null
? new HashSet<String>()
: Sets.newHashSet(action.properties.getUsers());
boolean seenAllUsers = false;
String userMarker = null;
while (!seenAllUsers) {
ListUsersType listUsersType =
MessageHelper.createMessage(ListUsersType.class, action.info.getEffectiveUserId());
;
if (userMarker != null) {
listUsersType.setMarker(userMarker);
}
ListUsersResponseType listUsersResponseType =
AsyncRequests.<ListUsersType, ListUsersResponseType>sendSync(
configuration, listUsersType);
if (listUsersResponseType.getListUsersResult().getIsTruncated() == Boolean.TRUE) {
userMarker = listUsersResponseType.getListUsersResult().getMarker();
} else {
seenAllUsers = true;
}
if (listUsersResponseType.getListUsersResult().getUsers() != null
&& listUsersResponseType.getListUsersResult().getUsers().getMemberList() != null) {
for (UserType userType :
listUsersResponseType.getListUsersResult().getUsers().getMemberList()) {
if (passedInUsers.contains(userType.getUserName())) {
realUsersToRemovePolicyFrom.add(userType.getUserName());
}
}
}
}
for (String user : realUsersToRemovePolicyFrom) {
DeleteUserPolicyType deleteUserPolicyType =
MessageHelper.createMessage(
DeleteUserPolicyType.class, action.info.getEffectiveUserId());
deleteUserPolicyType.setUserName(user);
deleteUserPolicyType.setPolicyName(action.properties.getPolicyName());
AsyncRequests.<DeleteUserPolicyType, DeleteUserPolicyResponseType>sendSync(
configuration, deleteUserPolicyType);
}
}
// find all groups that still exist from the list and remove the policy
if (action.properties.getGroups() != null && action.properties.getGroups().size() > 0) {
List<String> realGroupsToRemovePolicyFrom = Lists.newArrayList();
Set<String> passedInGroups =
action.properties.getGroups() == null
? new HashSet<String>()
: Sets.newHashSet(action.properties.getGroups());
boolean seenAllGroups = false;
String groupMarker = null;
while (!seenAllGroups) {
ListGroupsType listGroupsType =
MessageHelper.createMessage(ListGroupsType.class, action.info.getEffectiveUserId());
if (groupMarker != null) {
listGroupsType.setMarker(groupMarker);
}
ListGroupsResponseType listGroupsResponseType =
AsyncRequests.<ListGroupsType, ListGroupsResponseType>sendSync(
configuration, listGroupsType);
if (listGroupsResponseType.getListGroupsResult().getIsTruncated() == Boolean.TRUE) {
groupMarker = listGroupsResponseType.getListGroupsResult().getMarker();
} else {
seenAllGroups = true;
}
if (listGroupsResponseType.getListGroupsResult().getGroups() != null
&& listGroupsResponseType.getListGroupsResult().getGroups().getMemberList()
!= null) {
for (GroupType groupType :
listGroupsResponseType.getListGroupsResult().getGroups().getMemberList()) {
if (passedInGroups.contains(groupType.getGroupName())) {
realGroupsToRemovePolicyFrom.add(groupType.getGroupName());
}
}
}
}
for (String group : realGroupsToRemovePolicyFrom) {
DeleteGroupPolicyType deleteGroupPolicyType =
MessageHelper.createMessage(
DeleteGroupPolicyType.class, action.info.getEffectiveUserId());
deleteGroupPolicyType.setGroupName(group);
deleteGroupPolicyType.setPolicyName(action.properties.getPolicyName());
AsyncRequests.<DeleteGroupPolicyType, DeleteGroupPolicyResponseType>sendSync(
configuration, deleteGroupPolicyType);
}
}
return action;
}
