public async Task DeleteTxtRecordAsync(DnsZone zone, string relativeRecordName)
{
var recordName = $"{relativeRecordName}.{zone.Name}.";
var listRequest = new ListResourceRecordSetsRequest(zone.Id)
{
StartRecordName = recordName,
StartRecordType = RRType.TXT
};
var listResponse = await _amazonRoute53Client.ListResourceRecordSetsAsync(listRequest);
if (listResponse.ResourceRecordSets.Count == 0)
{
return;
}
var changes = listResponse.ResourceRecordSets
.Select(x => new Change {
Action = ChangeAction.DELETE, ResourceRecordSet = x
})
.ToList();
var request = new ChangeResourceRecordSetsRequest(zone.Id, new ChangeBatch(changes));
await _amazonRoute53Client.ChangeResourceRecordSetsAsync(request);
}
public IEnumerable <ResourceRecordSet> GetResourceRecordSets(HostedZone zone)
{
var request = new ListResourceRecordSetsRequest(zone.Id);
ListResourceRecordSetsResponse response = _route53Client.ListResourceRecordSets(request);
return(response.ResourceRecordSets);
}
/// <summary>
/// To retrieve a list of record sets for a particular hosted zone.
/// </summary>
/// <param name="hostedZoneId">The ID of the hosted zone whos record sets you want to list</param>
/// <param name="settings">The <see cref="Route53Settings"/> required to connect to Route53.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
public async Task <IList <ResourceRecordSet> > GetResourceRecordSets(string hostedZoneId, Route53Settings settings, CancellationToken cancellationToken = default(CancellationToken))
{
if (String.IsNullOrEmpty(hostedZoneId))
{
throw new ArgumentNullException("hostedZoneId");
}
ListResourceRecordSetsRequest request = new ListResourceRecordSetsRequest(hostedZoneId);
AmazonRoute53Client client = this.GetClient(settings);
ListResourceRecordSetsResponse response = await client.ListResourceRecordSetsAsync(request);
if (response.HttpStatusCode == HttpStatusCode.OK)
{
_Log.Verbose("Listing record sets");
return(response.ResourceRecordSets);
}
else
{
_Log.Error("Could not list record sets");
return(null);
}
}
private async Task <ListResourceRecordSetsResponse> getAwsResourceRecordsAsync(string hostedZoneId)
{
logger.LogInformation($"Getting List of Resource Records for hosted zone ID { hostedZoneId }...");
ListResourceRecordSetsRequest request = new ListResourceRecordSetsRequest
{
HostedZoneId = hostedZoneId
};
ListResourceRecordSetsResponse records = await TheRoute53Client().ListResourceRecordSetsAsync(request);
return(records);
}
public static ListResourceRecordSetsResponse GetResourceRecordSets(IAmazonRoute53 r53Client)
{
var request = new ListResourceRecordSetsRequest
{
HostedZoneId = Zoneid,
StartRecordName = Fqdn,
StartRecordType = "A",
MaxItems = "100"
};
var response = r53Client.ListResourceRecordSets(request);
return(response);
}
public ListResourceRecordSetsResponse listRecordSets(string hostedZoneId,
string startRecordIdentifier, string startRecordName, string startRecordType)
{
logger.Info("Calling ListResourceRecordSets");
ListResourceRecordSetsRequest request = new ListResourceRecordSetsRequest()
{
HostedZoneId = hostedZoneId,
StartRecordIdentifier = startRecordIdentifier,
StartRecordName = startRecordName,
StartRecordType = startRecordType
};
return(client.ListResourceRecordSets(request));
}
private async Task <string> LookupIpAddressByZoneIdAndDNSName(string id, string dnsName)
{
var request = new ListResourceRecordSetsRequest
{
HostedZoneId = id,
StartRecordName = dnsName
};
var response = await R53.ListResourceRecordSetsAsync(request);
if (response.ResourceRecordSets.Count == 0 || response.ResourceRecordSets[0].ResourceRecords.Count == 0)
{
return(string.Empty);
}
return(response.ResourceRecordSets[0].ResourceRecords[0].Value);
}
public static void ListHostNames()
{
if (!quiet)
{
Console.WriteLine($"Domain = {domain}");
}
string zoneId = FindHostedZoneID(domain);
if (zoneId == null)
{
throw new Exception("Zone not found");
}
bool more = true;
bool first = true;
string start = "";
while (more)
{
ListResourceRecordSetsRequest r = new ListResourceRecordSetsRequest(zoneId);
r.MaxItems = "150";
if (!first)
{
r.StartRecordName = start;
}
first = false;
ListResourceRecordSetsResponse res = c.ListResourceRecordSetsAsync(r).Result;
foreach (var s in res.ResourceRecordSets)
{
string firstVal = (s.ResourceRecords != null && s.ResourceRecords.Count > 0) ? s.ResourceRecords[0].Value : "";
Console.WriteLine($"{s.Name.PadRight(60)}" + (quiet ? "" : $"\t{s.Type}\t{firstVal}"));
/*
* if (!quiet)
* {
* foreach(var rr in s.ResourceRecords)
* {
* Console.WriteLine($"\t{rr.Value}");
* }
* }
*/
}
more = res.IsTruncated;
if (more)
{
start = res.NextRecordName;
}
}
}
private static async Task <ResourceRecordSet> GetResourceRecordSet(string hostedZoneID, string domainName)
{
try
{
var listResourceRecordSetsRequest = new ListResourceRecordSetsRequest(hostedZoneID);
var listResourceRecordSetsResponse = await client.ListResourceRecordSetsAsync(listResourceRecordSetsRequest);
return(listResourceRecordSetsResponse.ResourceRecordSets.SingleOrDefault(x => x.Name == domainName && x.Type == RRType.A));
}
catch (Exception exception)
{
logger.Error(exception, "");
throw;
}
}
/// <summary>
///
/// </summary>
/// <param name="hostzoneId">Sample: /hostedzone/ZW9CIJG5IAQYD</param>
/// <param name="resourceRecordSetName">Sample api.infra.safearrival.testschoolmessenger.com.</param>
/// <returns>Example: infra-Admin-ALB-747523918.us-east-2.elb.amazonaws.com (Regular)Or
/// admin.infra.safearrival.testschoolmessenger.com.s3-website.us-east-2.amazonaws.com (Maintenance)</returns>
public async Task <List <string> > GetRecorSetValues(string hostzoneId, List <string> resourceRecordSetNames)
{
var ret = new List <string>();
var request = new ListResourceRecordSetsRequest()
{
HostedZoneId = hostzoneId,
//StartRecordName = resourceRecordSetName
};
var response = await client.ListResourceRecordSetsAsync(request);
foreach (var name in resourceRecordSetNames)
{
var recordSet = response.ResourceRecordSets.Find(o => o.Name == name);
if (recordSet != null && recordSet.ResourceRecords.Count > 0)
{
ret.Add(recordSet.ResourceRecords[0].Value);
}
}
return(ret);
}
public void TestRoute53()
{
var geoLocations = Client.ListGeoLocations(new ListGeoLocationsRequest()).GeoLocationDetailsList;
Assert.IsNotNull(geoLocations);
Assert.AreNotEqual(0, geoLocations.Count);
CreateHostedZoneRequest createRequest = new CreateHostedZoneRequest
{
Name = ZONE_NAME,
CallerReference = CALLER_REFERENCE,
HostedZoneConfig = new HostedZoneConfig {
Comment = COMMENT
}
};
// Create Hosted Zone
var response = Client.CreateHostedZone(createRequest);
createdZoneId = response.HostedZone.Id;
createdZoneChangeId = response.ChangeInfo.Id;
assertValidCreatedHostedZone(response.HostedZone);
assertValidDelegationSet(response.DelegationSet);
assertValidChangeInfo(response.ChangeInfo);
Assert.IsNotNull(response.Location);
// Get Hosted Zone
GetHostedZoneRequest getRequest = new GetHostedZoneRequest {
Id = createdZoneId
};
var getHostedZoneResponse = Client.GetHostedZone(getRequest);
assertValidDelegationSet(getHostedZoneResponse.DelegationSet);
assertValidCreatedHostedZone(getHostedZoneResponse.HostedZone);
// List Hosted Zones
List <HostedZone> hostedZones = Client.ListHostedZones().HostedZones;
Assert.IsTrue(hostedZones.Count > 0);
foreach (HostedZone hostedZone in hostedZones)
{
Assert.IsNotNull(hostedZone.CallerReference);
Assert.IsNotNull(hostedZone.Id);
Assert.IsNotNull(hostedZone.Name);
}
// List Resource Record Sets
ListResourceRecordSetsRequest listRequest = new ListResourceRecordSetsRequest {
HostedZoneId = createdZoneId, MaxItems = "10"
};
List <ResourceRecordSet> resourceRecordSets = Client.ListResourceRecordSets(listRequest).ResourceRecordSets;
Assert.IsTrue(resourceRecordSets.Count > 0);
ResourceRecordSet existingResourceRecordSet = resourceRecordSets[0];
foreach (ResourceRecordSet rrset in resourceRecordSets)
{
Assert.IsNotNull(rrset.Name);
Assert.IsNotNull(rrset.Type);
Assert.IsNotNull(rrset.TTL);
Assert.IsTrue(rrset.ResourceRecords.Count > 0);
}
// Get Change
ChangeInfo changeInfo = Client.GetChange(new GetChangeRequest {
Id = createdZoneChangeId
}).ChangeInfo;
Assert.IsTrue(changeInfo.Id.EndsWith(createdZoneChangeId));
assertValidChangeInfo(changeInfo);
// Change Resource Record Sets
ResourceRecordSet newResourceRecordSet = new ResourceRecordSet
{
Name = ZONE_NAME,
ResourceRecords = existingResourceRecordSet.ResourceRecords,
TTL = existingResourceRecordSet.TTL + 100,
Type = existingResourceRecordSet.Type,
HealthCheckId = null
};
changeInfo = Client.ChangeResourceRecordSets(new ChangeResourceRecordSetsRequest
{
HostedZoneId = createdZoneId,
ChangeBatch = new ChangeBatch
{
Comment = COMMENT,
Changes = new List <Change>
{
new Change {
Action = "DELETE", ResourceRecordSet = existingResourceRecordSet
},
new Change {
Action = "CREATE", ResourceRecordSet = newResourceRecordSet
}
}
}
}).ChangeInfo;
assertValidChangeInfo(changeInfo);
// Delete Hosted Zone
DeleteHostedZoneResult deleteHostedZoneResult = Client.DeleteHostedZone(new DeleteHostedZoneRequest {
Id = createdZoneId
});
assertValidChangeInfo(deleteHostedZoneResult.ChangeInfo);
}
public async Task HandleTermR53(Instance inst, Dictionary <string, string> tags)
{
_logger.LogInformation("Handling REMOVING R53 records");
var r53Spec = ResolveR53Spec(inst, tags);
var r53Routing = ResolveR53RoutingSpec(inst, tags);
var rrset = new ResourceRecordSet
{
Name = r53Spec.Name,
Type = RRType.FindValue(r53Spec.Type),
TTL = r53Spec.TTL,
ResourceRecords = new List <ResourceRecord>
{
new ResourceRecord(r53Spec.Value),
},
};
// Optional routing policy configuration
r53Routing?.Apply(rrset);
var listRequ = new ListResourceRecordSetsRequest
{
HostedZoneId = r53Spec.Zone,
StartRecordName = r53Spec.Name,
StartRecordType = r53Spec.Type,
StartRecordIdentifier = null,
};
var listResp = await _r53.ListResourceRecordSetsAsync(listRequ);
var rr = listResp.ResourceRecordSets.FirstOrDefault();
if (rr == null ||
rr.Name != r53Spec.Name ||
rr.Type != r53Spec.Type)
{
_logger.LogWarning("No existing resource records found; SKIPPING");
_logger.LogInformation("First returned record for query:");
_logger.LogInformation(JsonSerializer.Serialize(rr));
return;
}
var changeRequ = new ChangeResourceRecordSetsRequest
{
HostedZoneId = r53Spec.Zone,
ChangeBatch = new ChangeBatch
{
Changes = new List <Change>
{
new Change
{
Action = ChangeAction.DELETE,
ResourceRecordSet = rrset,
}
}
}
};
var changeResp = await _r53.ChangeResourceRecordSetsAsync(changeRequ);
_logger.LogInformation("DELETE request completed, response:");
_logger.LogInformation(JsonSerializer.Serialize(changeResp));
}
public List <MultiClientEntry> GetClients()
{
//Output
Output($"MCS: Starting Get Clients");
//1) Get the current data-text from R53
//New the Route 53 Client
AmazonRoute53Client r53Client =
new AmazonRoute53Client(
Config.BaseSettings.AWSAccessKeyID,
Config.BaseSettings.AWSSecretAccessKey,
new AmazonRoute53Config
{
RegionEndpoint = RegionEndpoint
});
//Define the request
ListResourceRecordSetsRequest listResourceRecordSetsRequest =
new ListResourceRecordSetsRequest
{
HostedZoneId = Config.MultiClientSettings.Route53.R53ZoneId,
MaxItems = 1.ToString(),
StartRecordName = Config.MultiClientSettings.Route53.Name
};
//Get the response
ListResourceRecordSetsResponse listResourceRecordSetsResponse =
r53Client
.ListResourceRecordSetsAsync(listResourceRecordSetsRequest)
.GetAwaiter()
.GetResult();
//Get the Data Text (if any)
//listResourceRecordSetsResponse.ResourceRecordSets[0].ResourceRecords[0].Value
string dataText =
listResourceRecordSetsResponse
.ResourceRecordSets?
.Where(rrsi => string.Equals(rrsi.Name, Config.MultiClientSettings.Route53.Name, StringComparison.InvariantCultureIgnoreCase))
.FirstOrDefault()?
.ResourceRecords?
.FirstOrDefault()?
.Value?
.Trim('"');
if (string.IsNullOrWhiteSpace(dataText) || string.IsNullOrWhiteSpace(dataText.Trim('"')))
{
//Since there somehow were no existing data in R53
//We just return an empty list
//Output
Output($"MCS: Found no existing record");
//return
return(new List <MultiClientEntry>());
}
//2) Decode the data string to a JSON string (decompress, decrypt)
//Decrypt and Decompress
dataText = dataText.DecryptThenDecompress(Config.MultiClientSettings.Route53.EncryptionPassword);
//3) Turn the Data Text into List
//De-serialize the JSON to the return value
List <MultiClientEntry> multiClientEntries =
JsonConvert.DeserializeObject <List <MultiClientEntry> >(dataText);
//Output
Output($"MCS: Completed Get Clients. Got {multiClientEntries.Count}");
//return
return(multiClientEntries);
}
public override Task <ListResourceRecordSetsResponse> ListResourceRecordSetsAsync(ListResourceRecordSetsRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
string ipAddress = string.Empty;
if (request.HostedZoneId == TestConstants.FakeHostedZoneId)
{
if (request.StartRecordName == TestConstants.FakePublicDNSName)
{
ipAddress = TestConstants.FakePublicIpAddress;
ListResourceRecordSetsPublicCalled = true;
}
else if (request.StartRecordName == TestConstants.FakePrivateDNSName)
{
ipAddress = TestConstants.FakePrivateIpAddress;
ListResourceRecordSetsPrivateCalled = true;
}
TimesListResourceRecordSetsCalled++;
}
var fake = new ListResourceRecordSetsResponse
{
IsTruncated = false,
ResourceRecordSets = new List <ResourceRecordSet>
{
new ResourceRecordSet
{
Type = RRType.A,
Name = request.StartRecordName,
ResourceRecords = new List <ResourceRecord>
{
new ResourceRecord {
Value = ipAddress
}
}
}
}
};
return(Task.Run(() => fake));
}
public virtual Task <ListResourceRecordSetsResponse> ListResourceRecordSetsAsync(ListResourceRecordSetsRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public async Task HandleTermR53(Instance inst, Dictionary <string, string> tags, string ec2State)
{
_logger.LogInformation("Handling REMOVING R53 records");
var r53Record = ResolveR53RecordSpec(inst, tags);
var r53Routing = ResolveR53RoutingSpec(inst, tags);
var r53Health = await ResolveR53HealthCheckSpec(inst, tags);
HealthCheck existingHealth = await FindExistingHealthCheck(r53Health);
if (r53Record != null)
{
var rrset = new ResourceRecordSet
{
Name = r53Record.Name,
Type = RRType.FindValue(r53Record.Type),
TTL = r53Record.TTL,
ResourceRecords = new List <ResourceRecord>
{
new ResourceRecord(r53Record.Value),
},
};
// Optional routing policy configuration
r53Routing?.Apply(rrset);
if (existingHealth != null)
{
rrset.HealthCheckId = existingHealth.Id;
}
var listRequ = new ListResourceRecordSetsRequest
{
HostedZoneId = r53Record.Zone,
StartRecordName = r53Record.Name,
StartRecordType = r53Record.Type,
StartRecordIdentifier = r53Routing?.SetIdentifier,
};
var listResp = await _r53.ListResourceRecordSetsAsync(listRequ);
var rr = listResp.ResourceRecordSets.FirstOrDefault();
if (rr == null ||
rr.Name != r53Record.Name ||
rr.Type != r53Record.Type ||
(r53Routing != null && !string.Equals(rr.SetIdentifier, r53Routing.SetIdentifier)))
{
_logger.LogWarning("No existing resource records found; SKIPPING");
_logger.LogInformation("First returned record for query:");
_logger.LogInformation(JsonSerializer.Serialize(rr));
}
else
{
var changeRequ = new ChangeResourceRecordSetsRequest
{
HostedZoneId = r53Record.Zone,
ChangeBatch = new ChangeBatch
{
Changes = new List <Change>
{
new Change
{
Action = ChangeAction.DELETE,
ResourceRecordSet = rrset,
}
}
}
};
var changeResp = await _r53.ChangeResourceRecordSetsAsync(changeRequ);
_logger.LogInformation("DELETE request completed, response:");
_logger.LogInformation(JsonSerializer.Serialize(changeResp));
}
}
// We delete the Health Check if any, second because
// the preceding Route policy may depend on it
if (existingHealth != null &&
(ec2State == EC2StateChangeStates.ShuttingDown ||
ec2State == EC2StateChangeStates.Terminated))
{
if (existingHealth != null)
{
_logger.LogInformation($"Found existing Health Check record [{existingHealth.Id}]");
var deleteRequ = new DeleteHealthCheckRequest
{
HealthCheckId = existingHealth.Id,
};
var deleteResp = await _r53.DeleteHealthCheckAsync(deleteRequ);
_logger.LogInformation("DELETE Health Check request completed, response:");
_logger.LogInformation(JsonSerializer.Serialize(deleteResp));
}
}
}
