Refactor converge.rs to make the overall flow clearer.

This entails moving a bunch of things into more appropriate modules, as well.

1 files changed, 34 insertions, 50 deletions

diff --git a/src/converge.rs b/src/converge.rs
index e79ac06..e203a5a 100644
--- a/src/converge.rs
+++ b/src/converge.rs
@@ -1,16 +1,15 @@
+use std::collections::HashSet;
 use std::fmt::Debug;
 
 use anyhow::Result;
-use aws_sdk_autoscaling::types::AutoScalingGroup;
 use aws_sdk_route53::types::ResourceRecordSet;
 use futures::try_join;
 use trust_dns_proto::rr::Name;
 
-use crate::autoscaling::{asg_by_name, AutoScaling};
-use crate::dns::AutoScalingGroupConfig;
-use crate::ec2::{instance_recordsets, Ec2};
+use crate::autoscaling::{propose_asg_recordsets, AutoScaling};
+use crate::ec2::Ec2;
 use crate::hashable::Hashable;
-use crate::route53::{zone_for_domain, zone_suffix_recordsets, Route53};
+use crate::route53::{host_recordsets, zone_for_domain, Route53};
 
 #[derive(Debug)]
 pub struct Changes<T> {
@@ -19,64 +18,49 @@ pub struct Changes<T> {
     pub insert: T,
 }
 
-async fn changes<C>(
+pub async fn named_asg_changes<C>(
     aws_context: &C,
-    auto_scaling_group: &AutoScalingGroup,
+    asg_name: &str,
     dns_name: &Name,
     dns_ttl: i64,
 ) -> Result<Changes<impl IntoIterator<Item = ResourceRecordSet> + Debug>>
 where
-    C: Ec2 + Route53,
+    C: AutoScaling + Ec2 + Route53,
 {
-    let AutoScalingGroupConfig {
-        name: asg_name,
-        live_instance_ids,
-    } = AutoScalingGroupConfig::try_from(auto_scaling_group)?;
-
     let zone = zone_for_domain(aws_context, dns_name).await?;
-    let zone_id = zone.id();
 
-    let (intended_records, actual_records) = try_join!(
-        instance_recordsets(
-            aws_context,
-            &asg_name,
-            dns_name,
-            dns_ttl,
-            &live_instance_ids,
-        ),
-        zone_suffix_recordsets(aws_context, zone_id, dns_name),
+    let (proposed, actual) = try_join!(
+        propose_asg_recordsets(aws_context, asg_name, dns_name, dns_ttl),
+        host_recordsets(aws_context, &zone.id, dns_name),
     )?;
 
-    let remove_records = actual_records.difference(&intended_records);
-    let insert_records = intended_records.difference(&actual_records);
-
-    let remove_records = remove_records.map(Hashable::as_ref);
-    let insert_records = insert_records.map(Hashable::as_ref);
-
-    let remove_records = remove_records.map(ToOwned::to_owned);
-    let insert_records = insert_records.map(ToOwned::to_owned);
-
-    let remove_records: Vec<_> = remove_records.collect();
-    let insert_records: Vec<_> = insert_records.collect();
-
-    Ok(Changes {
-        zone_id: zone_id.into(),
-        remove: remove_records,
-        insert: insert_records,
-    })
+    let changes = changes_for_records(&zone.id, &proposed, &actual);
+    Ok(changes)
 }
 
-pub async fn named_asg_changes<C>(
-    aws_context: &C,
-    name: &str,
-    dns_name: &Name,
-    dns_ttl: i64,
-) -> Result<Changes<impl IntoIterator<Item = ResourceRecordSet> + Debug>>
+fn changes_for_records<T>(
+    zone_id: &str,
+    intended: &HashSet<Hashable<T>>,
+    actual: &HashSet<Hashable<T>>,
+) -> Changes<impl IntoIterator<Item = T> + Debug>
 where
-    C: AutoScaling + Ec2 + Route53,
+    Hashable<T>: Eq + std::hash::Hash,
+    T: Clone + Debug,
 {
-    let auto_scaling_group = asg_by_name(aws_context, name).await?;
+    let remove: Vec<_> = actual
+        .difference(intended)
+        .map(Hashable::as_ref)
+        .cloned()
+        .collect();
+    let insert: Vec<_> = intended
+        .difference(actual)
+        .map(Hashable::as_ref)
+        .cloned()
+        .collect();
 
-    let changes = changes(aws_context, &auto_scaling_group, dns_name, dns_ttl).await?;
-    Ok(changes)
+    Changes {
+        zone_id: zone_id.into(),
+        remove,
+        insert,
+    }
 }