public DlgEditDnsRecord(ZAwsEc2Controller controller, ResourceRecordSet records)
{
InitializeComponent();
MyController = controller;
MyRecords = records;
comboBoxRecordType.SelectedIndex = 0;
}
public ChangeResourceRecordSetsResponse updateRRSet(
string hostedZoneId, ResourceRecordSet oldRRset, ResourceRecordSet newRRset)
{
logger.Info("Calling ChangeResourceRecordSets");
Change delete = new Change()
{
Action = Action.DELETE.ToString(),
ResourceRecordSet = oldRRset
};
Change create = new Change()
{
Action = Action.CREATE.ToString(),
ResourceRecordSet = newRRset
};
List <Change> changes = new List <Change>()
{
delete, create
};
ChangeBatch batch = new ChangeBatch()
{
Changes = changes
};
return(client.ChangeResourceRecordSets(new ChangeResourceRecordSetsRequest()
{
HostedZoneId = hostedZoneId,
ChangeBatch = batch
}));
}
private async Task <ChangeResourceRecordSetsResponse> createAws_A_ResourceRecords(string hostedZoneId, string hostName)
{
ChangeBatch changes = new ChangeBatch();
string newHostName = hostName.Substring(0, hostName.Length - 1);
logger.LogInformation($"Creating Alias Record for hosted zone { newHostName }...");
ResourceRecordSet aliasRs = new ResourceRecordSet()
{
AliasTarget = new AliasTarget()
{
HostedZoneId = "Z3AQBSTGFYJSTF", //use zone id from here: https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region
DNSName = "s3-website-us-east-1.amazonaws.com",
EvaluateTargetHealth = false
},
Type = RRType.A,
Name = newHostName
};
Change AliasRecord = new Change(ChangeAction.CREATE, aliasRs);
changes.Changes.Add(AliasRecord);
ChangeResourceRecordSetsRequest request = new ChangeResourceRecordSetsRequest()
{
ChangeBatch = changes,
HostedZoneId = hostedZoneId
};
ChangeResourceRecordSetsResponse response = await TheRoute53Client().ChangeResourceRecordSetsAsync(request);
return(response);
}
private ResourceRecordSet cloneRRSetWithNewValue(ResourceRecordSet RRSet, string myIP)
{
ResourceRecordSet ret = new ResourceRecordSet()
{
AliasTarget = RRSet.AliasTarget,
Name = RRSet.Name,
SetIdentifier = RRSet.SetIdentifier,
TTL = RRSet.TTL,
Type = RRSet.Type
};
ResourceRecord rr = new ResourceRecord()
{
Value = myIP
};
ret.ResourceRecords = new List <ResourceRecord>()
{
rr
};
// Route53 doesn't accept zero weights, and if you set it to zero you'll get an error!
if (RRSet.Weight != 0)
{
ret.Weight = RRSet.Weight;
}
return(ret);
}
public async Task <bool> UpdateIpAddressForSubdomain(string hostedZoneId, string fqdn, string newIpAddress)
{
using (AmazonRoute53Client route53Client = GetAmazonRoute53Client())
{
ListResourceRecordSetsResponse records = await route53Client.ListResourceRecordSetsAsync(new ListResourceRecordSetsRequest(hostedZoneId));
// Look for an A record matching the FQDN that was passed in
ResourceRecordSet matchingRecordSet = records?.ResourceRecordSets.FirstOrDefault(prop => prop.Name == fqdn && prop.Type == RRType.A);
if (matchingRecordSet != null && matchingRecordSet.ResourceRecords.Any())
{
if (matchingRecordSet.ResourceRecords.First().Value != newIpAddress)
{
matchingRecordSet.ResourceRecords.First().Value = newIpAddress;
ChangeBatch change = new ChangeBatch();
change.Changes.Add(new Change(ChangeAction.UPSERT, matchingRecordSet));
ChangeResourceRecordSetsResponse changeRequest = await route53Client.ChangeResourceRecordSetsAsync(new ChangeResourceRecordSetsRequest(hostedZoneId, change));
Log.Information("[Runtime = {StartTime}] Change request submitted to change subdomain {Subdomain} IP address to {IPAddress}.", Settings.StartTime, fqdn, newIpAddress);
return(changeRequest.HttpStatusCode == System.Net.HttpStatusCode.OK);
}
else
{
Log.Information("[Runtime = {StartTime}] Subdomain {Subdomain} found, but the IP address was already {IPAddress}.", Settings.StartTime, fqdn, newIpAddress);
}
}
return(false);
}
}
private bool ApplyDnsChange(HostedZone zone, ResourceRecordSet recordSet, ChangeAction action)
{
// Prepare change as Batch
Change changeDetails = new Change()
{
ResourceRecordSet = recordSet,
Action = action
};
ChangeBatch changeBatch = new ChangeBatch()
{
Changes = new List <Change> {
changeDetails
}
};
// Prepare zone's resource record sets
var recordsetRequest = new ChangeResourceRecordSetsRequest()
{
HostedZoneId = zone.Id,
ChangeBatch = changeBatch
};
logger.Debug($"Route53 :: ApplyDnsChange : ChangeResourceRecordSets: {recordsetRequest.ChangeBatch} ");
var recordsetResponse = route53Client.ChangeResourceRecordSets(recordsetRequest);
logger.Debug($"Route53 :: ApplyDnsChange : ChangeResourceRecordSets Response: {recordsetResponse} ");
logger.Info("DNS change completed.");
return(true);
}
public static void SetRoutes(FargateResourceV2 resource,
FargateResourceV2 resourceNew, ELBHelper elb, Route53Helper r53, CloudWatchHelper cw)
{
Console.WriteLine("Fetching DNS Private Record...");
var newPrivateRecord = r53.GetCNameRecordSet(resourceNew.ZonePrivate, resourceNew.DNSCName, throwIfNotFound: true)
.Result.PrintResponse();
Console.WriteLine($"Upserting Health Check...");
var healthCheck = r53.UpsertCloudWatchHealthCheckAsync(
resource.HealthCheckName,
alarmName: resourceNew.ELBHealthyMetricAlarmName,
alarmRegion: resource.Region,
throwIfNotFound: false,
insufficientDataHealthStatus: Amazon.Route53.InsufficientDataHealthStatus.Healthy,
inverted: false
).Result.PrintResponse();
ResourceRecordSet newPublicRecord = null;
Console.WriteLine("Updating Private Route53 Record Set (PRIMARY)...");
var t1 = r53.UpsertCNameRecordAsync(resource.ZonePrivate, resource.DNSCName, newPrivateRecord.ResourceRecords.Single().Value, ttl: resourceNew.TTL,
failover: "PRIMARY", setIdentifier: "PRIMARY-PRIVATE", healthCheckId: healthCheck.Id);
Console.WriteLine("Updating Private Route53 Record Set (SECONDARY)...");
var t2 = r53.UpsertCNameRecordAsync(resourceNew.ZonePrivate, resource.DNSCName, newPrivateRecord.ResourceRecords.Single().Value, ttl: resourceNew.TTL,
failover: "SECONDARY", setIdentifier: "SECONDARY-PRIVATE");
if (resourceNew.IsPublic)
{
Console.WriteLine("Fetching DNS Public Record...");
newPublicRecord = r53.GetCNameRecordSet(resourceNew.ZonePublic, resourceNew.DNSCName, throwIfNotFound: resourceNew.IsPublic)
.Result.PrintResponse();
Console.WriteLine("Updating Public Route53 Record Set (PRIMARY)...");
var t3 = r53.UpsertCNameRecordAsync(resource.ZonePublic, resource.DNSCName, newPublicRecord.ResourceRecords.Single().Value, ttl: resourceNew.TTL,
failover: "PRIMARY", setIdentifier: "PRIMARY-PUBLIC", healthCheckId: healthCheck.Id);
Console.WriteLine("Updating Public Route53 Record Set (SECONDARY)...");
var t4 = r53.UpsertCNameRecordAsync(resourceNew.ZonePublic, resource.DNSCName, newPublicRecord.ResourceRecords.Single().Value, ttl: resourceNew.TTL,
failover: "SECONDARY", setIdentifier: "SECONDARY-PUBLIC");
Task.WhenAll(t1, t3);
Task.WhenAll(t2, t4);
}
t1.Await();
t2.Await();
Console.WriteLine($"Awaiting {(resource.TTL + 1) * 2} [s] for DNS route update based on TTL...");
Thread.Sleep((resource.TTL + 1) * 2 * 1000);
Console.WriteLine($"Awaiting Health Check Healthy Status...");
r53.WaitForHealthCheckAsync(name: healthCheck.Id, status: Route53Helper.HealthCheckStatus.Healthy, timeout_s: resource.HealthCheckTimeout).Result.PrintResponse();
Console.WriteLine($"Ensuring DNS Route53 Resolution into new address after Health Check change...");
AwaitDnsUpsert(resource, resourceNew, r53, resource.DnsResolveTimeout).PrintResponse();
}
private static async Task UpdateResourceRecordSet(ResourceRecordSet resourceRecordSet, Domain domain)
{
var change = new Change(ChangeAction.UPSERT, resourceRecordSet);
var changeBatch = new ChangeBatch(new List <Change> {
change
});
var request = new ChangeResourceRecordSetsRequest(domain.HostedZoneID, changeBatch);
//var response = await client.ChangeResourceRecordSetsAsync(request);
}
/// <summary>
/// Create or change a DNS record for a hosted zone.
/// </summary>
/// <param name="hostedZoneId">The ID of the hosted zone that contains the resource record sets that you want to change</param>
/// <param name="name">The name of the DNS record set.</param>
/// <param name="type">The type of the DNS record set.</param>
/// <param name="value">The value of the record set.</param>
/// <param name="ttl">The time to live of the record set.</param>
/// <param name="settings">The <see cref="Route53Settings"/> required to upload to Amazon S3.</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 <string> CreateResourceRecordSet(string hostedZoneId, string name, RRType type, string value, long ttl, Route53Settings settings, CancellationToken cancellationToken = default(CancellationToken))
{
var recordSet = new ResourceRecordSet()
{
Name = name,
TTL = ttl,
Type = type,
ResourceRecords = new List <ResourceRecord>
{
new ResourceRecord {
Value = value
}
}
};
var change1 = new Change()
{
ResourceRecordSet = recordSet,
Action = ChangeAction.UPSERT
};
var changeBatch = new ChangeBatch()
{
Changes = new List <Change> {
change1
}
};
var recordsetRequest = new ChangeResourceRecordSetsRequest()
{
HostedZoneId = hostedZoneId,
ChangeBatch = changeBatch
};
AmazonRoute53Client client = this.GetClient(settings);
ChangeResourceRecordSetsResponse response = await client.ChangeResourceRecordSetsAsync(recordsetRequest);
if (response.HttpStatusCode == HttpStatusCode.OK)
{
await this.WaitForChange(client, response.ChangeInfo.Id, 10000, 60);
_Log.Verbose("Updated record set");
return(response.ChangeInfo.Id);
}
else
{
_Log.Error("Could not change resource records");
return("");
}
}
internal void DeleteRecord(ResourceRecordSet s)
{
ChangeResourceRecordSetsResponse resp =
myController.route53.ChangeResourceRecordSets(new ChangeResourceRecordSetsRequest()
.WithHostedZoneId(this.ResponseData.Id)
.WithChangeBatch(new ChangeBatch()
.WithChanges(
new Change()
.WithAction("DELETE")
.WithResourceRecordSet(s))));
Thread.Sleep(2000);
UpdateInfo();
}
public ChangeResourceRecordSetsResponse updateRRSet(string hostedZoneId, ResourceRecordSet oldRRset, ResourceRecordSet newRRset)
{
logger.Info("Calling ChangeResourceRecordSets");
List <Change> changes = new List <Change>()
{
new Change().WithAction(Action.DELETE.ToString()).WithResourceRecordSet(oldRRset),
new Change().WithAction(Action.CREATE.ToString()).WithResourceRecordSet(newRRset)
};
ChangeBatch batch = new ChangeBatch().WithChanges(changes.ToArray());
return(client.ChangeResourceRecordSets(new ChangeResourceRecordSetsRequest()
.WithHostedZoneId(hostedZoneId)
.WithChangeBatch(batch)));
}
public void Apply(ResourceRecordSet rrset)
{
rrset.SetIdentifier = SetIdentifier;
if (MultiValue.HasValue)
{
rrset.MultiValueAnswer = MultiValue.Value;
}
if (Weight.HasValue)
{
rrset.Weight = Weight.Value;
}
rrset.Failover = Failover;
rrset.Region = LatencyRegion;
rrset.GeoLocation = GeoLocation;
}
protected override void ProcessRecord()
{
base.ProcessRecord();
ResourceRecordSet rrset = new ResourceRecordSet
{
Kind = "dns#resourceRecordSet",
Name = Name,
Rrdatas = Rrdata,
Ttl = Ttl,
Type = Type
};
WriteObject(rrset);
}
private static void CreateHostedZone(IAmazonRoute53 r53Client, string domainName)
{
var zoneRequest = new CreateHostedZoneRequest
{
Name = domainName,
CallerReference = "testingss"
};
var zoneResponse = r53Client.CreateHostedZone(zoneRequest);
var recordSet = new ResourceRecordSet
{
Name = domainName,
TTL = 60,
Type = RRType.A,
ResourceRecords = new List <ResourceRecord> {
new ResourceRecord {
Value = IpAddress
}
}
};
var change1 = new Change
{
ResourceRecordSet = recordSet,
Action = ChangeAction.CREATE
};
var changeBatch = new ChangeBatch
{
Changes = new List <Change> {
change1
}
};
var recordsetRequest = new ChangeResourceRecordSetsRequest
{
HostedZoneId = zoneResponse.HostedZone.Id,
ChangeBatch = changeBatch
};
var recordsetResponse = r53Client.ChangeResourceRecordSets(recordsetRequest);
var changeRequest = new GetChangeRequest
{
Id = recordsetResponse.ChangeInfo.Id
};
Console.WriteLine(changeRequest);
}
private ResourceRecordSet cloneRRSetWithNewValue(ResourceRecordSet RRSet, string myIP)
{
ResourceRecordSet ret = new ResourceRecordSet()
.WithAliasTarget(RRSet.AliasTarget)
.WithName(RRSet.Name)
.WithSetIdentifier(RRSet.SetIdentifier)
.WithTTL(RRSet.TTL)
.WithType(RRSet.Type)
.WithResourceRecords(new List <ResourceRecord>()
{
new ResourceRecord().WithValue(myIP)
});
// Route53 doesn't accept zero weights, and if you set it to zero you'll get an error!
return(RRSet.Weight != 0 ? ret.WithWeight(RRSet.Weight) : ret);
}
private async Task <bool> ApplyDnsChange(HostedZone zone, ResourceRecordSet recordSet, ChangeAction action)
{
// prepare change
var changeDetails = new Change()
{
ResourceRecordSet = recordSet,
Action = action
};
var changeBatch = new ChangeBatch()
{
Changes = new List <Change> {
changeDetails
}
};
// Update the zone's resource record sets
var recordsetRequest = new ChangeResourceRecordSetsRequest()
{
HostedZoneId = zone.Id,
ChangeBatch = changeBatch
};
_log?.Debug($"Route53 :: ApplyDnsChange : ChangeResourceRecordSetsAsync: {JsonConvert.SerializeObject(recordsetRequest.ChangeBatch)} ");
var recordsetResponse = await _route53Client.ChangeResourceRecordSetsAsync(recordsetRequest);
_log?.Debug($"Route53 :: ApplyDnsChange : ChangeResourceRecordSetsAsync Response: {JsonConvert.SerializeObject(recordsetResponse)} ");
// Monitor the change status
var changeRequest = new GetChangeRequest()
{
Id = recordsetResponse.ChangeInfo.Id
};
while (ChangeStatus.PENDING == (await _route53Client.GetChangeAsync(changeRequest)).ChangeInfo.Status)
{
System.Diagnostics.Debug.WriteLine("DNS change is pending.");
await Task.Delay(1500);
}
_log?.Information("DNS change completed.");
return(true);
}
public void copyNsRecordsFromSubDomainToParentDomain(string fullSubDomainName, string parentName)
{
Task <ListHostedZonesResponse> ListOfHostedZones = listAwsHostedZonesAsync();
ListOfHostedZones.Wait();
HostedZone subZone = ListOfHostedZones.Result.HostedZones.Find(h => h.Name == $"{ fullSubDomainName }.");
HostedZone parentZone = ListOfHostedZones.Result.HostedZones.Find(h => h.Name == $"{ parentName }.");
Task <ListResourceRecordSetsResponse> getResourceRecords = getAwsResourceRecordsAsync(subZone.Id);
getResourceRecords.Wait();
ResourceRecordSet rrs = getResourceRecords.Result.ResourceRecordSets.Find(r => r.Name == $"{ fullSubDomainName }." && r.Type == RRType.NS);
Task <ChangeResourceRecordSetsResponse> ResourceResponse = createAws_NS_ResourceRecords(parentZone.Id, fullSubDomainName, rrs);
ResourceResponse.Wait();
}
public async Task HandleInitR53(Instance inst, Dictionary <string, string> tags)
{
_logger.LogInformation("Handling CREATING 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 changeRequ = new ChangeResourceRecordSetsRequest
{
HostedZoneId = r53Spec.Zone,
ChangeBatch = new ChangeBatch
{
Changes = new List <Change>
{
new Change
{
Action = ChangeAction.UPSERT,
ResourceRecordSet = rrset,
}
}
}
};
var changeResp = await _r53.ChangeResourceRecordSetsAsync(changeRequ);
_logger.LogInformation("UPSERT request completed, response:");
_logger.LogInformation(JsonSerializer.Serialize(changeResp));
}
internal void Update(string hostname, IPAddress ipAddress)
{
var lhzTask = route53Client.ListHostedZonesAsync();
ResourceRecord resourceRecord = new ResourceRecord(ipAddress.ToString());
ResourceRecordSet resourceRecordSet = new ResourceRecordSet
{
Name = hostname,
TTL = 30,
Type = RRType.A,
ResourceRecords = new List <ResourceRecord> {
resourceRecord
}
};
Change change = new Change
{
Action = ChangeAction.UPSERT,
ResourceRecordSet = resourceRecordSet
};
ChangeBatch changeBatch = new ChangeBatch
{
Changes = new List <Change> {
change
},
Comment = DateTime.UtcNow.ToString("s", System.Globalization.CultureInfo.InvariantCulture)
};
// This is wrong and does The Wrong Thing, I'm fairly certain
string domain = DomainName.Parse(hostname).Domain;
var zones = lhzTask.Result.HostedZones;
string hostedZoneId = zones.Single(z => z.Name.StartsWith(domain)).Id;
ChangeResourceRecordSetsRequest request = new ChangeResourceRecordSetsRequest
{
ChangeBatch = changeBatch,
HostedZoneId = hostedZoneId
};
var crrsTask = route53Client.ChangeResourceRecordSetsAsync(request);
var response = crrsTask.Result;
}
private async static Task <bool> UpdateIpAddressForSubdomain(string hostedZoneId, string fqdn, string newIpAddress)
{
AmazonRoute53Config config = new AmazonRoute53Config()
{
RegionEndpoint = RegionEndpoint.GetBySystemName(Settings.AWSRegion) // TODO: inject
};
using (AmazonRoute53Client route53Client = new AmazonRoute53Client(Settings.AWSAccessKeyId, Settings.AWSAccessKeySecret, config))
{
ListResourceRecordSetsResponse records = await route53Client.ListResourceRecordSetsAsync(new ListResourceRecordSetsRequest(hostedZoneId));
ResourceRecordSet matchingRecordSet = records?.ResourceRecordSets.FirstOrDefault(prop => prop.Name == fqdn && prop.Type == RRType.A);
if (matchingRecordSet != null && matchingRecordSet.ResourceRecords.FirstOrDefault() != null)
{
if (matchingRecordSet.ResourceRecords.FirstOrDefault().Value != newIpAddress)
{
matchingRecordSet.ResourceRecords.FirstOrDefault().Value = newIpAddress;
ChangeBatch change = new ChangeBatch();
change.Changes.Add(new Change(ChangeAction.UPSERT, matchingRecordSet));
ChangeResourceRecordSetsResponse changeRequest = await route53Client.ChangeResourceRecordSetsAsync(new ChangeResourceRecordSetsRequest(hostedZoneId, change));
Log.Information("[Runtime = {StartTime}] Change request submitted to change subdomain {Subdomain} IP address to {IPAddress}.", startTime, fqdn, newIpAddress);
return(changeRequest.HttpStatusCode == System.Net.HttpStatusCode.OK);
}
else
{
Log.Information("[Runtime = {StartTime}] Subdomain {Subdomain} found, but the IP address was already {IPAddress}.", startTime, fqdn, newIpAddress);
}
}
else
{
// New subdomain
Log.Information("[Runtime = {StartTime}] Subdomain {Subdomain} record not found.", startTime, fqdn);
}
return(false);
}
}
public static void UpdateRoute53Record(string hostname, IPAddress newIp)
{
var route53Client = new AmazonRoute53Client(
Settings.AwsAccessKeyId,
Settings.AwsSecretAccessKey,
Amazon.RegionEndpoint.USEast1);
var recordSet = new ResourceRecordSet
{
Name = hostname,
TTL = 60,
Type = RRType.A,
ResourceRecords = new List <ResourceRecord>
{
new ResourceRecord {
Value = newIp.ToString()
}
}
};
var changeBatch = new ChangeBatch
{
Changes = new List <Change>
{
new Change
{
ResourceRecordSet = recordSet,
Action = ChangeAction.UPSERT
}
}
};
var recordsetRequest = new ChangeResourceRecordSetsRequest
{
HostedZoneId = Settings.HostedZoneId,
ChangeBatch = changeBatch
};
route53Client.ChangeResourceRecordSets(recordsetRequest);
}
private ChangeResourceRecordSetsRequest GetChangeResourceRecordSetsRequest(string hostname, string ipAddress, string action, List <HostedZone> zones)
{
string domain = DomainName.Parse(hostname).Domain;
string hostedZoneId = zones.Single(z => z.Name.StartsWith(domain)).Id;
var record = new ResourceRecord()
{
Value = ipAddress
};
var recordSet = new ResourceRecordSet()
{
Name = hostname,
TTL = 300, //5 min.
Type = DnsRecordType.A,
ResourceRecords = new List <ResourceRecord> {
record
}
};
var change = new Change()
{
Action = action, ResourceRecordSet = recordSet
};
var request = new ChangeResourceRecordSetsRequest()
{
ChangeBatch = new ChangeBatch()
{
Changes = new List <Change> {
change
},
Comment = string.Format("Automatically updated by {0}", this.ToString())
},
HostedZoneId = hostedZoneId
};
return(request);
}
internal bool AddRecord(ResourceRecordSet s)
{
try
{
ChangeResourceRecordSetsResponse resp =
myController.route53.ChangeResourceRecordSets(new ChangeResourceRecordSetsRequest()
.WithHostedZoneId(this.ResponseData.Id)
.WithChangeBatch(new ChangeBatch()
.WithChanges(
new Change()
.WithAction("CREATE")
.WithResourceRecordSet(s))));
Thread.Sleep(2000);
UpdateInfo();
return(true);
}
catch (Exception ex)
{
Program.TraceLine("Failed adding a recordset, reason: ", ex);
return(false);
}
}
public async Task <ResourceRecordSet> CreateTxtRecord(string projectId, ManagedZone zone, string name, string value)
{
if (!name.EndsWith("."))
{
name += ".";
}
var body = new ResourceRecordSet();
body.Kind = "dns#resourceRecordSet";
body.Name = name;
body.Type = "TXT";
body.Ttl = 0;
body.Rrdatas = new List <string>()
{
"\"" + value + "\""
};
var request = _client.Projects.ManagedZones.Rrsets.Create(body, projectId, zone.Name);
return(await request.ExecuteAsync());
}
public async Task ProcessRecord(string zoneId, ResourceRecordSet record, Amazon.EC2.Model.Instance instance,
bool enabled,
string name,
long ttl,
string address)
{
if (!enabled)
{
if (record == null)
{
Log($"No need to destroy, record '{name}' does not exists for zone '{zoneId}'. Tags Origin: EC2 Instance {instance.InstanceId} ({instance.GetTagValueOrDefault("Name")})");
return; //no need to update, record does not exist
}
else
{
Log($"Destroying record {record.Name} linked to EC2 Instance {instance.InstanceId} ({instance.GetTagValueOrDefault("Name")})...");
await _R53.DestroyRecord(zoneId, record.Name, record.Type);
}
return;
}
if (record?.Type == RRType.A &&
record?.ResourceRecords.Any(r => r.Value == address) == true &&
record?.TTL == ttl)
{
Log($"Correct record already exists for EC2 Instance {instance.InstanceId} ({instance.GetTagValueOrDefault("Name")})");
return; //no need to update, correct record already exists
}
Log($"Updating record of EC2 Instance {instance.InstanceId} ({instance.GetTagValueOrDefault("Name")}), Old Record Name: '{record?.Name}'...");
await _R53.UpsertRecordAsync(
zoneId : zoneId,
Name : name,
Value : address,
Type : RRType.A,
TTL : ttl);
}
public static async Task Create(this HostedZone zone, Credentials credentials)
{
var client = credentials.CreateClient();
//[3] Create a resource record set change batch
var recordSet = new ResourceRecordSet {
Name = zone.Name,
TTL = 60,
Type = RRType.A,
ResourceRecords = new List <ResourceRecord> {
new ResourceRecord {
Value = "192.0.2.235"
}
}
};
var change1 = new Change {
ResourceRecordSet = recordSet,
Action = ChangeAction.CREATE
};
var changeBatch = new ChangeBatch {
Changes = new List <Change> {
change1
}
};
//[4] Update the zone's resource record sets
var recordsetRequest = new ChangeResourceRecordSetsRequest {
HostedZoneId = zone.Id,
ChangeBatch = changeBatch
};
var recordsetResponse = client.ChangeResourceRecordSets(recordsetRequest);
var status = await recordsetResponse.ChangeInfo.WaitForStatusAync(credentials);
}
private static void CreateRecordSet(IAmazonRoute53 r53Client)
{
var objRecord = new ResourceRecord {
Value = "Your IP Address"
};
var objRecordSet = new ResourceRecordSet
{
Name = Fqdn,
Type = "A",
TTL = 300
};
objRecordSet.ResourceRecords.Add(objRecord);
var objChange = new Change
{
Action = ChangeAction.UPSERT,
ResourceRecordSet = objRecordSet
};
var objChangeList = new List <Change> {
objChange
};
var objChangeBatch = new ChangeBatch {
Changes = objChangeList
};
var objRequest = new ChangeResourceRecordSetsRequest
{
HostedZoneId = Zoneid,
ChangeBatch = objChangeBatch
};
r53Client.ChangeResourceRecordSets(objRequest);
}
public async Task <ActionResult> CreateRecord(DnsRecord request)
{
// https://docs.aws.amazon.com/sdk-for-net/v2/developer-guide/route53-apis-intro.html
// find zone
var zone = await ResolveMatchingZone(request);
if (zone != null)
{
// get existing record set for current TXT records with this name
var response = await _route53Client.ListResourceRecordSetsAsync(
new ListResourceRecordSetsRequest
{
StartRecordName = request.RecordName,
StartRecordType = "TXT",
MaxItems = "1",
HostedZoneId = zone.Id
}
);
var targetRecordSet = response.ResourceRecordSets.FirstOrDefault(r => (r.Name == request.RecordName || r.Name == request.RecordName + ".") && r.Type.Value == "TXT");
if (targetRecordSet != null)
{
targetRecordSet.ResourceRecords.Add(
new ResourceRecord {
Value = "\"" + request.RecordValue + "\""
}
);
}
else
{
targetRecordSet = new ResourceRecordSet()
{
Name = request.RecordName,
TTL = 5,
Type = RRType.TXT,
ResourceRecords = new List <ResourceRecord>
{
new ResourceRecord {
Value = "\"" + request.RecordValue + "\""
}
}
};
}
try
{
// requests for *.domain.com + domain.com use the same TXT record name, so we
// need to allow multiple entires rather than doing Upsert
var result = await ApplyDnsChange(zone, targetRecordSet, ChangeAction.UPSERT);
return(new ActionResult {
IsSuccess = true, Message = $"Dns Record Created/Updated: {request.RecordName}"
});
}
catch (AmazonRoute53Exception exp)
{
return(new ActionResult {
IsSuccess = false, Message = $"Dns Record Create/Update: {request.RecordName} - {exp.Message}"
});
}
}
else
{
return(new ActionResult {
IsSuccess = false, Message = "DNS Zone match could not be determined."
});
}
}
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 IRequest Marshall(ChangeResourceRecordSetsRequest changeResourceRecordSetsRequest)
{
IRequest request = new DefaultRequest(changeResourceRecordSetsRequest, "AmazonRoute53");
request.HttpMethod = "POST";
string uriResourcePath = "/2012-12-12/hostedzone/{Id}/rrset/";
uriResourcePath = uriResourcePath.Replace("{Id}", changeResourceRecordSetsRequest.HostedZoneId ?? "");
if (uriResourcePath.Contains("?"))
{
string queryString = uriResourcePath.Substring(uriResourcePath.IndexOf("?") + 1);
uriResourcePath = uriResourcePath.Substring(0, uriResourcePath.IndexOf("?"));
foreach (string s in queryString.Split('&', ';'))
{
string[] nameValuePair = s.Split('=');
if (nameValuePair.Length == 2 && nameValuePair[1].Length > 0)
{
request.Parameters.Add(nameValuePair[0], nameValuePair[1]);
}
else
{
request.Parameters.Add(nameValuePair[0], null);
}
}
}
request.ResourcePath = uriResourcePath;
StringWriter stringWriter = new StringWriter();
XmlTextWriter xmlWriter = new XmlTextWriter(stringWriter);
xmlWriter.Namespaces = true;
xmlWriter.WriteStartElement("ChangeResourceRecordSetsRequest", "https://route53.amazonaws.com/doc/2012-12-12/");
if (changeResourceRecordSetsRequest != null)
{
ChangeBatch changeBatchChangeBatch = changeResourceRecordSetsRequest.ChangeBatch;
if (changeBatchChangeBatch != null)
{
xmlWriter.WriteStartElement("ChangeBatch", "https://route53.amazonaws.com/doc/2012-12-12/");
if (changeBatchChangeBatch.IsSetComment())
{
xmlWriter.WriteElementString("Comment", "https://route53.amazonaws.com/doc/2012-12-12/", changeBatchChangeBatch.Comment.ToString());
}
if (changeBatchChangeBatch != null)
{
List <Change> changeBatchChangeBatchchangesList = changeBatchChangeBatch.Changes;
if (changeBatchChangeBatchchangesList != null && changeBatchChangeBatchchangesList.Count > 0)
{
int changeBatchChangeBatchchangesListIndex = 1;
xmlWriter.WriteStartElement("Changes", "https://route53.amazonaws.com/doc/2012-12-12/");
foreach (Change changeBatchChangeBatchchangesListValue in changeBatchChangeBatchchangesList)
{
xmlWriter.WriteStartElement("Change", "https://route53.amazonaws.com/doc/2012-12-12/");
if (changeBatchChangeBatchchangesListValue.IsSetAction())
{
xmlWriter.WriteElementString("Action", "https://route53.amazonaws.com/doc/2012-12-12/", changeBatchChangeBatchchangesListValue.Action.ToString());
}
if (changeBatchChangeBatchchangesListValue != null)
{
ResourceRecordSet resourceRecordSetResourceRecordSet = changeBatchChangeBatchchangesListValue.ResourceRecordSet;
if (resourceRecordSetResourceRecordSet != null)
{
xmlWriter.WriteStartElement("ResourceRecordSet", "https://route53.amazonaws.com/doc/2012-12-12/");
if (resourceRecordSetResourceRecordSet.IsSetName())
{
xmlWriter.WriteElementString("Name", "https://route53.amazonaws.com/doc/2012-12-12/", resourceRecordSetResourceRecordSet.Name.ToString());
}
if (resourceRecordSetResourceRecordSet.IsSetType())
{
xmlWriter.WriteElementString("Type", "https://route53.amazonaws.com/doc/2012-12-12/", resourceRecordSetResourceRecordSet.Type.ToString());
}
if (resourceRecordSetResourceRecordSet.IsSetSetIdentifier())
{
xmlWriter.WriteElementString("SetIdentifier", "https://route53.amazonaws.com/doc/2012-12-12/", resourceRecordSetResourceRecordSet.SetIdentifier.ToString());
}
if (resourceRecordSetResourceRecordSet.IsSetWeight())
{
xmlWriter.WriteElementString("Weight", "https://route53.amazonaws.com/doc/2012-12-12/", resourceRecordSetResourceRecordSet.Weight.ToString());
}
if (resourceRecordSetResourceRecordSet.IsSetRegion())
{
xmlWriter.WriteElementString("Region", "https://route53.amazonaws.com/doc/2012-12-12/", resourceRecordSetResourceRecordSet.Region.ToString());
}
if (resourceRecordSetResourceRecordSet.IsSetFailover())
{
xmlWriter.WriteElementString("Failover", "https://route53.amazonaws.com/doc/2012-12-12/", resourceRecordSetResourceRecordSet.Failover.ToString());
}
if (resourceRecordSetResourceRecordSet.IsSetTTL())
{
xmlWriter.WriteElementString("TTL", "https://route53.amazonaws.com/doc/2012-12-12/", resourceRecordSetResourceRecordSet.TTL.ToString());
}
if (resourceRecordSetResourceRecordSet != null)
{
List <ResourceRecord> resourceRecordSetResourceRecordSetresourceRecordsList = resourceRecordSetResourceRecordSet.ResourceRecords;
if (resourceRecordSetResourceRecordSetresourceRecordsList != null && resourceRecordSetResourceRecordSetresourceRecordsList.Count > 0)
{
int resourceRecordSetResourceRecordSetresourceRecordsListIndex = 1;
xmlWriter.WriteStartElement("ResourceRecords", "https://route53.amazonaws.com/doc/2012-12-12/");
foreach (ResourceRecord resourceRecordSetResourceRecordSetresourceRecordsListValue in resourceRecordSetResourceRecordSetresourceRecordsList)
{
xmlWriter.WriteStartElement("ResourceRecord", "https://route53.amazonaws.com/doc/2012-12-12/");
if (resourceRecordSetResourceRecordSetresourceRecordsListValue.IsSetValue())
{
xmlWriter.WriteElementString("Value", "https://route53.amazonaws.com/doc/2012-12-12/", resourceRecordSetResourceRecordSetresourceRecordsListValue.Value.ToString());
}
xmlWriter.WriteEndElement();
resourceRecordSetResourceRecordSetresourceRecordsListIndex++;
}
xmlWriter.WriteEndElement();
}
}
if (resourceRecordSetResourceRecordSet != null)
{
AliasTarget aliasTargetAliasTarget = resourceRecordSetResourceRecordSet.AliasTarget;
if (aliasTargetAliasTarget != null)
{
xmlWriter.WriteStartElement("AliasTarget", "https://route53.amazonaws.com/doc/2012-12-12/");
if (aliasTargetAliasTarget.IsSetHostedZoneId())
{
xmlWriter.WriteElementString("HostedZoneId", "https://route53.amazonaws.com/doc/2012-12-12/", aliasTargetAliasTarget.HostedZoneId.ToString());
}
if (aliasTargetAliasTarget.IsSetDNSName())
{
xmlWriter.WriteElementString("DNSName", "https://route53.amazonaws.com/doc/2012-12-12/", aliasTargetAliasTarget.DNSName.ToString());
}
if (aliasTargetAliasTarget.IsSetEvaluateTargetHealth())
{
xmlWriter.WriteElementString("EvaluateTargetHealth", "https://route53.amazonaws.com/doc/2012-12-12/", aliasTargetAliasTarget.EvaluateTargetHealth.ToString().ToLower());
}
xmlWriter.WriteEndElement();
}
}
if (resourceRecordSetResourceRecordSet.IsSetHealthCheckId())
{
xmlWriter.WriteElementString("HealthCheckId", "https://route53.amazonaws.com/doc/2012-12-12/", resourceRecordSetResourceRecordSet.HealthCheckId.ToString());
}
xmlWriter.WriteEndElement();
}
}
xmlWriter.WriteEndElement();
changeBatchChangeBatchchangesListIndex++;
}
xmlWriter.WriteEndElement();
}
}
xmlWriter.WriteEndElement();
}
}
xmlWriter.WriteEndElement();
try
{
request.Content = System.Text.Encoding.UTF8.GetBytes(stringWriter.ToString());
request.Headers.Add("Content-Type", "application/xml");
}
catch (EncoderFallbackException e)
{
throw new AmazonServiceException("Unable to marshall request to XML", e);
}
return(request);
}
protected override void ProcessRecord()
{
base.ProcessRecord();
ResourceRecordSet rrset = new ResourceRecordSet
{
Kind = "dns#resourceRecordSet",
Name = Name,
Rrdatas = Rrdata,
Ttl = Ttl,
Type = Type
};
WriteObject(rrset);
}
