sprinkle_dns 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1fab0389257851cf18cca41f85ba7902d2d6991599f6f41467612fad0861f754
+  data.tar.gz: daa92a1e2c7a5ad893c606bfadc181e355c76622ee55bc905f8a1afcda734f2a
+SHA512:
+  metadata.gz: c2e87abb06df0034e18b215e688fd6808452fbb95fa105d95a4ab6f1532b4bdc7d35db72ae0ef8afda82f6d445dcfc21e200cb7bb07ca70cb83d1711555aaa22
+  data.tar.gz: c26276c21b51b54b22a589fcfe622bee85261cf20f9907b36ea7792a300ea81e2e31a830ae8967b0e35c89ada0636f0b8c347261c3fe6b1c2710d483f6b066fb

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/
+test_perms.rb
+coverage

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.ruby-version

@@ -0,0 +1 @@
+2.6.2

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,76 @@
+PATH
+  remote: .
+  specs:
+    sprinkle_dns (1.0.0)
+      aws-sdk-route53 (~> 1.21)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.6.0)
+      public_suffix (>= 2.0.2, < 4.0)
+    aws-eventstream (1.0.3)
+    aws-partitions (1.160.0)
+    aws-sdk-core (3.50.0)
+      aws-eventstream (~> 1.0, >= 1.0.2)
+      aws-partitions (~> 1.0)
+      aws-sigv4 (~> 1.1)
+      jmespath (~> 1.0)
+    aws-sdk-route53 (1.22.0)
+      aws-sdk-core (~> 3, >= 3.48.2)
+      aws-sigv4 (~> 1.1)
+    aws-sigv4 (1.1.0)
+      aws-eventstream (~> 1.0, >= 1.0.2)
+    coderay (1.1.2)
+    crack (0.4.3)
+      safe_yaml (~> 1.0.0)
+    diff-lcs (1.3)
+    docile (1.3.1)
+    hashdiff (0.3.9)
+    jmespath (1.4.0)
+    json (2.2.0)
+    method_source (0.9.2)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    public_suffix (3.0.3)
+    rake (12.3.2)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    safe_yaml (1.0.5)
+    simplecov (0.16.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    vcr (3.0.3)
+    webmock (2.3.2)
+      addressable (>= 2.3.6)
+      crack (>= 0.3.2)
+      hashdiff
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  pry (~> 0.12)
+  rake (~> 12.3)
+  rspec (~> 3.8)
+  simplecov (~> 0.16)
+  sprinkle_dns!
+  vcr (~> 3.0)
+  webmock (~> 2.3)
+
+BUNDLED WITH
+   1.17.2

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2015 Billetto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,181 @@
+![SprinkleDNS logo](logos/SDNS.png)
+
+# SprinkleDNS
+
+A diff-based way of managing DNS for people with lots of domains for AWS Route53.
+
+## How
+
+Use plain old Ruby to define your DNS configuration:
+
+```ruby
+require 'sprinkle_dns'
+
+client = SprinkleDNS::Route53Client.new(ACCESS_KEY_ID, SECRET_ACCESS_KEY)
+sdns   = SprinkleDNS::Client.new(client)
+
+sdns.entry('A', 'www.billetto.com', '88.80.188.142', 360)
+sdns.entry('A', 'staging.billetto.com', '88.80.188.143', 360)
+
+sdns.sprinkle!
+```
+
+Or a more advanced example using loops and interpolation:
+
+```ruby
+require 'sprinkle_dns'
+
+client = SprinkleDNS::Route53Client.new(ACCESS_KEY_ID, SECRET_ACCESS_KEY)
+sdns   = SprinkleDNS::Client.new(client)
+
+domains = ['billetto.dk', 'billetto.co.uk', 'billetto.com',  'billetto.se']
+
+domains.each do |domain|
+  sdns.entry('A', domain, '88.80.188.142', 360)
+  sdns.entry('A', "www.#{domain}", '88.80.188.142', 360)
+
+  s.entry("CNAME", "docs.#{domain}",  'ghs.googlehosted.com', 43200)
+  s.entry("CNAME", "mail.#{domain}",  'ghs.googlehosted.com', 43200)
+  s.entry("CNAME", "drive.#{domain}", 'ghs.googlehosted.com', 43200)
+
+  s.entry("MX",    domain, ['1 aspmx.l.google.com',
+                            '5 alt1.aspmx.l.google.com',
+                            '5 alt2.aspmx.l.google.com',
+                            '10 aspmx2.googlemail.com',
+                            '10 aspmx3.googlemail.com'], 60)
+end
+
+# Overwrite one of the domains, to test our new loadbalancer:
+sdns.entry('A', 'billetto.com', '89.81.189.143', 360)
+
+sdns.sprinkle!
+```
+
+## Configuration
+
+You can configure the `SprinkleDNS::Client` like so:
+
+```ruby
+client = SprinkleDNS::Route53Client.new(ACCESS_KEY_ID, SECRET_ACCESS_KEY)
+sdns = SprinkleDNS::Client.new(client,
+  dry_run: false,
+  diff: true,
+  force: true,
+  delete: false,
+  interactive_progress: true,
+  create_hosted_zones: false,
+)
+```
+
+Here is a table that shows the different configuration options:
+
+| Name                   | Description                                                                                               | Default value |
+|------------------------|-----------------------------------------------------------------------------------------------------------|---------------|
+| `dry_run`              | Do not make any changes, just compare and exit, useful with `diff: true`.                                 | `true`        |
+| `diff`                 | Prints a diff to list the changes that are going to be made.                                              | `true`        |
+| `force`                | Do not ask before changes are made, just apply.                                                           | `false`       |
+| `delete`               | Specifies whether unreferenced entries should be deleted.                                                 | `false`       |
+| `interactive_progress` | Shows interactive progress whilst changes are being applied, nice for your terminal, not for your CI-job. | `true`        |
+| `create_hosted_zones`  | Specifies whether or not hosted zones should be created.                                                  | `false`       |
+
+### `dry_run` and `diff`
+
+`dry_run` is useful combined with `diff` because it will let you see the changes in a safe manner without any changes being applied:
+
+![dry_run and diff](readme_files/dry_run_and_diff.png)
+
+### `force: false`
+
+With `force` being set to `false` you will be asked whether or not you want to apply the changes:
+
+![force set to false](readme_files/force_false.png)
+
+### `delete: true`
+
+With `delete` being set to `true` SprinkleDNS will delete **any** entries not being referenced, these will also show up in the diff (if it is enabled):
+
+![delete true shows up in diffs](readme_files/delete_true_and_diff.png)
+
+### `create_hosted_zones: true`
+
+With `create_hosted_zones` set to `true`, SprinkleDNS will create a hosted zone if not existing, it requires the `route53:CreateHostedZone` permission.
+
+## Support for ALIAS-records
+
+Route53 supports ALIAS-records to achieve CNAME-flattening, SprinkleDNS also supports that, here we point our root domain to an ELB:
+
+```ruby
+require 'sprinkle_dns'
+
+client = SprinkleDNS::Route53Client.new(ACCESS_KEY_ID, SECRET_ACCESS_KEY)
+sdns   = SprinkleDNS::Client.new(client)
+
+sdns.alias('A', 'billetto.com', 'Z215JYRZR1TBD5', 'dualstack.mothership-test-elb-546580691.eu-central-1.elb.amazonaws.com')
+
+sdns.sprinkle!
+```
+
+## Amazon policy
+
+This gem uses the following permissions to manage hosted zones:
+
+- `route53:ListHostedZones`, for getting the list of hosted zones.
+- `route53:ListResourceRecordSets`, to read the records for a hosted zone.
+- `route53:ChangeResourceRecordSets`, to change records for a hosted zone.
+- `route53:GetChange`, for reading when a change have been applied.
+
+Additionally, you can consider adding the following permissions:
+
+- `route53:CreateHostedZone`, for allowing the gem to create hosted zones.
+
+You can allow it for all of your hosted zones:
+
+```json
+{
+    "Version": "2012-10-17",
+    "Statement": [
+        {
+            "Effect": "Allow",
+            "Action": [
+                "route53:ListResourceRecordSets",
+                "route53:ChangeResourceRecordSets",
+                "route53:GetChange",
+                "route53:ListHostedZones"
+            ],
+            "Resource": [
+                "*"
+            ]
+        }
+    ]
+}
+```
+
+For a more "locked down" policy you can use this (remember to update the `resource` array):
+
+```json
+{
+    "Version": "2012-10-17",
+    "Statement": [
+        {
+            "Effect": "Allow",
+            "Action": [
+                "route53:ListResourceRecordSets",
+                "route53:ChangeResourceRecordSets"
+            ],
+            "Resource": [
+                "arn:aws:route53:::hostedzone/Z3EATJAGJWXQE8"
+            ]
+        },
+        {
+            "Effect": "Allow",
+            "Action": [
+                "route53:GetChange",
+                "route53:ListHostedZones"
+            ],
+            "Resource": [
+                "*"
+            ]
+        }
+    ]
+}
+```

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/examples/example01.rb

@@ -0,0 +1,47 @@
+require 'sprinkle_dns'
+
+# require_relative '../test_perms'
+# client = SprinkleDNS::Route53Client.new(ACCESS_KEY_ID, SECRET_ACCESS_KEY)
+
+require 'sprinkle_dns/providers/mock_client'
+hz = SprinkleDNS::HostedZone.new('test.colourful.com.')
+pe01 = SprinkleDNS::HostedZoneEntry.new('A', 'noref.test.colourful.com.', Array.wrap('80.80.80.80'), 3600, hz.name)
+pe02 = SprinkleDNS::HostedZoneEntry.new('A', 'updateme.test.colourful.com.', Array.wrap('80.80.80.80'), 3600, hz.name)
+pe03 = SprinkleDNS::HostedZoneEntry.new('TXT', 'txt.test.colourful.com.', %Q{"#{Time.now.to_i}"}, 60, hz.name)
+pe04 = SprinkleDNS::HostedZoneEntry.new('A', 'nochange.test.colourful.com.', Array.wrap('80.80.80.80'), 60, hz.name)
+sleep(1)
+# We are emulating that these records are already live, mark them as persisted
+[pe01, pe02, pe03, pe04].each do |persisted|
+  persisted.persisted!
+  hz.resource_record_sets << persisted
+end
+
+client = SprinkleDNS::MockClient.new([hz])
+sdns = SprinkleDNS::Client.new(client, delete: true, force: true)
+
+sdns.entry('A', 'noref.test.billetto.com.', '127.0.0.1', 7200, 'test.billetto.com')
+sdns.alias('A', 'www.test.billetto.com', 'Z215JYRZR1TBD5', 'dualstack.mothership-prod-elb-546580691.eu-central-1.elb.amazonaws.com', 'test.billetto.com')
+sdns.entry('A', 'updateme.test.billetto.com.', '90.90.90.90', 7200, 'test.billetto.com')
+sdns.entry('TXT', 'txt.test.billetto.com', %Q{"#{Time.now.to_i}"}, 60, 'test.billetto.com')
+sdns.entry('A', 'nochange.test.billetto.com.', '80.80.80.80', 60, 'test.billetto.com')
+
+existing_hosted_zones, _ = sdns.sprinkle!
+
+# ------------------------------------------------------------------------------------------
+# ##########################################################################################
+# ------------------------------------------------------------------------------------------
+
+sdns = SprinkleDNS::Client.new(client, delete: true, force: true)
+
+sdns.entry('A', 'www.test.billetto.com', '90.90.90.90', 7200, 'test.billetto.com')
+sdns.entry('A', 'updateme.test.billetto.com.', '90.90.90.90', 7200, 'test.billetto.com')
+#sdns.entry('TXT', 'txt.test.billetto.com', %Q{"#{Time.now.to_i}"}, 60, 'test.billetto.com')
+sdns.entry('A', 'nochange.test.billetto.com.', '80.80.80.80', 60, 'test.billetto.com')
+
+sdns.entry("MX", 'test.billetto.com', ['1 aspmx.l.google.com',
+                          '5 alt1.aspmx.l.google.com',
+                          '5 alt2.aspmx.l.google.com',
+                          '10 aspmx2.googlemail.com',
+                          '10 aspmx3.googlemail.com'], 60, 'test.billetto.com')
+
+existing_hosted_zones, _ = sdns.sprinkle!

data/examples/example02.rb

@@ -0,0 +1,61 @@
+require 'sprinkle_dns'
+require 'sprinkle_dns/providers/mock_client'
+
+hz01 = SprinkleDNS::HostedZone.new('colourful.co.uk.')
+pe01 = SprinkleDNS::HostedZoneEntry.new('A', 'noref.colourful.co.uk.', Array.wrap('80.80.80.80'), 3600, hz01.name)
+pe02 = SprinkleDNS::HostedZoneEntry.new('A', 'updateme.colourful.co.uk.', Array.wrap('80.80.80.80'), 3600, hz01.name)
+pe03 = SprinkleDNS::HostedZoneEntry.new('TXT', 'txt.colourful.co.uk.', %Q{"#{Time.now.to_i}"}, 60, hz01.name)
+pe04 = SprinkleDNS::HostedZoneEntry.new('A', 'unchanged.colourful.co.uk.', Array.wrap('80.80.80.80'), 60, hz01.name)
+
+# We are emulating that these records are already live, mark them as persisted
+[pe01, pe02, pe03, pe04].each do |persisted|
+  persisted.persisted!
+  hz01.resource_record_sets << persisted
+end
+
+hz02 = SprinkleDNS::HostedZone.new('colorful.com.')
+pe05 = SprinkleDNS::HostedZoneEntry.new('A', 'noref.colorful.com.', Array.wrap('80.80.80.80'), 3600, hz02.name)
+pe06 = SprinkleDNS::HostedZoneEntry.new('A', 'updateme.colorful.com.', Array.wrap('80.80.80.80'), 3600, hz02.name)
+pe07 = SprinkleDNS::HostedZoneEntry.new('TXT', 'txt.colorful.com.', %Q{"#{Time.now.to_i}"}, 60, hz02.name)
+pe08 = SprinkleDNS::HostedZoneEntry.new('A', 'nochange.colorful.com.', Array.wrap('80.80.80.80'), 60, hz02.name)
+
+# We are emulating that these records are already live, mark them as persisted
+[pe05, pe06, pe07, pe08].each do |persisted|
+  persisted.persisted!
+  hz02.resource_record_sets << persisted
+end
+
+hz03 = SprinkleDNS::HostedZone.new('kolorowy.pl.')
+pe09 = SprinkleDNS::HostedZoneEntry.new('A', 'noref.kolorowy.pl.', Array.wrap('80.80.80.80'), 3600, hz03.name)
+pe10 = SprinkleDNS::HostedZoneEntry.new('A', 'updateme.kolorowy.pl.', Array.wrap('80.80.80.80'), 3600, hz03.name)
+pe11 = SprinkleDNS::HostedZoneEntry.new('TXT', 'txt.kolorowy.pl.', %Q{"#{Time.now.to_i}"}, 60, hz03.name)
+pe12 = SprinkleDNS::HostedZoneEntry.new('A', 'nochange.kolorowy.pl.', Array.wrap('80.80.80.80'), 60, hz03.name)
+
+# We are emulating that these records are already live, mark them as persisted
+[pe09, pe10, pe11, pe12].each do |persisted|
+  persisted.persisted!
+  hz03.resource_record_sets << persisted
+end
+
+client = SprinkleDNS::MockClient.new([hz01, hz02, hz03])
+sdns = SprinkleDNS::Client.new(client, force: true, diff: true, delete: true, interactive_progress: true)
+
+sdns.entry('A', 'colourful.co.uk', '90.90.90.90', 3600)
+sdns.entry('A', 'updateme.colourful.co.uk', '90.90.90.90', 3600)
+sdns.entry('A', 'unchanged.colourful.co.uk', '80.80.80.80', 60)
+sdns.entry('TXT', 'txt.colourful.co.uk', %Q{"#{Time.now.to_i+1}"}, 60)
+sdns.entry('A', 'colorful.com.', '80.80.80.80', 3601)
+sdns.entry('A', 'kolorowy.pl.', '80.80.80.80', 3601)
+
+existing_hosted_zones, _ = sdns.sprinkle!
+
+puts "--------------------------------------------------------------------------------------------"
+
+client = SprinkleDNS::MockClient.new([hz02, hz01, hz03])
+sdns = SprinkleDNS::Client.new(client, delete: false, interactive_progress: false, force: false)
+
+sdns.entry('A', 'colourful.co.uk', '90.90.90.90', 3601)
+sdns.entry('A', 'colorful.com.', '80.80.80.80', 3601)
+sdns.entry('A', 'kolorowy.pl.', '80.80.80.80', 3601)
+
+existing_hosted_zones, _ = sdns.sprinkle!

data/examples/example03.rb

@@ -0,0 +1,27 @@
+require 'sprinkle_dns'
+
+require_relative 'test_perms'
+client = SprinkleDNS::Route53Client.new(ACCESS_KEY_ID, SECRET_ACCESS_KEY)
+
+25.times do |retry_count|
+  sdns = SprinkleDNS::Client.new(client, delete: true, force: true)
+
+  sdns.entry('A', 'www.mxtest.billetto.com', '90.90.90.90', 7200, 'mxtest.billetto.com')
+  sdns.entry('A', 'updateme.mxtest.billetto.com.', '90.90.90.90', 7200, 'mxtest.billetto.com')
+  sdns.entry('TXT', 'txt.mxtest.billetto.com', %Q{"#{Time.now.to_i}"}, 60, 'mxtest.billetto.com')
+  sdns.entry('A', 'nochange.mxtest.billetto.com.', '80.80.80.80', 60, 'mxtest.billetto.com')
+
+  sdns.entry("MX", 'mxtest.billetto.com', ['1 aspmx.l.google.com',
+                            '5 alt1.aspmx.l.google.com',
+                            '5 alt2.aspmx.l.google.com',
+                            '10 aspmx2.googlemail.com',
+                            '10 aspmx3.googlemail.com'], 60, 'mxtest.billetto.com')
+
+  existing_hosted_zones, _ = sdns.sprinkle!
+
+  sleep_time = (retry_count ** 4) + 15 + (rand(30) * (retry_count + 1))
+  sleep_time_time = Time.now + sleep_time
+  puts "Sleeping #{sleep_time} seconds until #{sleep_time_time}"
+  puts "------------------------------------------------------------------------------------"
+  sleep sleep_time
+end

data/examples/example04.rb

@@ -0,0 +1,22 @@
+require 'sprinkle_dns'
+require 'sprinkle_dns/providers/mock_client'
+
+hz01 = SprinkleDNS::HostedZone.new('colorful.com.')
+pe01 = SprinkleDNS::HostedZoneEntry.new('A', 'colorful.com.', Array.wrap('80.80.80.80'), 3601, hz01.name)
+# We are emulating that these records are already live, mark them as persisted
+[pe01].each do |persisted|
+  persisted.persisted!
+  hz01.resource_record_sets << persisted
+end
+
+client = SprinkleDNS::MockClient.new([hz01])
+sdns = SprinkleDNS::Client.new(client, force: false, diff: true, delete: true, interactive_progress: true, create_hosted_zones: true)
+
+sdns.entry('A', 'colourful.co.uk', '90.90.90.90', 3600)
+sdns.entry('A', 'updateme.colourful.co.uk', '90.90.90.90', 3600)
+sdns.entry('A', 'unchanged.colourful.co.uk', '80.80.80.80', 60)
+sdns.entry('TXT', 'txt.colourful.co.uk', %Q{"#{Time.now.to_i+1}"}, 60)
+sdns.entry('A', 'colorful.com.', '80.80.80.80', 3601)
+sdns.entry('A', 'kolorowy.pl.', '80.80.80.80', 3601)
+
+existing_hosted_zones, _ = sdns.sprinkle!

data/lib/sprinkle_dns/cli/hosted_zone_diff.rb

@@ -0,0 +1,206 @@
+module SprinkleDNS::CLI
+  class HostedZoneDiff
+    HostedZone = Struct.new(:action, :name)
+    Entry = Struct.new(:action, :type, :type_highlight, :name, :name_highlight, :value1, :value1_highlight, :value2, :value2_highlight, :hosted_zone)
+
+    def diff(existing_hosted_zones, missing_hosted_zones, configuration)
+      entries = []
+
+      hosted_zones = if configuration.create_hosted_zones?
+        (existing_hosted_zones + missing_hosted_zones)
+      else
+        existing_hosted_zones
+      end
+
+      hosted_zones.each do |hosted_zone|
+        policy_service = SprinkleDNS::EntryPolicyService.new(hosted_zone, configuration)
+
+        to_create = policy_service.entries_to_create
+        to_update = policy_service.entries_to_update
+        to_delete = policy_service.entries_to_delete
+
+        if missing_hosted_zones.include?(hosted_zone)
+          entries << hosted_zone_to_struct('+', hosted_zone)
+        end
+
+        hosted_zone.entries.each do |entry|
+          if to_create.include?(entry)
+            entries << entry_to_struct('+', entry, hosted_zone)
+          elsif to_update.include?(entry)
+            old_entry = entry
+            new_entry = entry.new_entry
+
+            entries << entry_to_struct('u-', old_entry, hosted_zone)
+            entries << entry_to_struct('u+', new_entry, hosted_zone, old_entry)
+          elsif to_delete.include?(entry)
+            entries << entry_to_struct('-', entry, hosted_zone)
+          else
+            entries << entry_to_struct(nil, entry, hosted_zone)
+          end
+        end
+      end
+
+      coloured_entries = []
+
+      entries.each do |e|
+        colour_mod = case e.action
+        when '+'
+          ->(text) { "#{fg(*green)}#{text}#{color_reset}" }
+        when '-'
+          ->(text) { "#{fg(*red)}#{text}#{color_reset}" }
+        when nil
+          ->(text) { "#{text}" }
+        end
+
+        colour_mod_highlight = case e.action
+        when '+'
+          ->(text) { "#{fg(*black)}#{bg(*green)}#{text}#{color_reset}" }
+        when '-'
+          ->(text) { "#{fg(*black)}#{bg(*red)}#{text}#{color_reset}" }
+        when nil
+          ->(text) { "#{text}" }
+        end
+
+        case e
+        when HostedZone
+          information = [colour_mod.call(e.action), colour_mod_highlight.call(bold(e.name))]
+        when Entry
+          information = [colour_mod.call(e.action)]
+
+          information << if e.type_highlight
+            colour_mod_highlight.call(e.type)
+          else
+            colour_mod.call(e.type)
+          end
+
+          information << if e.name_highlight
+            colour_mod_highlight.call(e.name)
+          else
+            colour_mod.call(e.name)
+          end
+
+          information << if e.value1_highlight
+            colour_mod_highlight.call(e.value1)
+          else
+            colour_mod.call(e.value1)
+          end
+
+          information << if e.value2_highlight
+            colour_mod_highlight.call(e.value2)
+          else
+            colour_mod.call(e.value2)
+          end
+        end
+
+        coloured_entries << information.compact.delete_if(&:empty?)
+      end
+
+      coloured_entries
+    end
+
+    private
+
+    def hex_to_rgb(hex)
+      hex_split = hex.match(/#(..)(..)(..)/)
+      [hex_split[1], hex_split[2], hex_split[3]].map(&:hex)
+    end
+
+    def red
+     hex_to_rgb('#ff6e67')
+    end
+
+    def green
+     hex_to_rgb('#5bf68c')
+    end
+
+    def black
+     hex_to_rgb('#000000')
+    end
+
+    def fg(r, g, b)
+      "\x1b[38;2;#{r};#{g};#{b}m"
+    end
+
+    def bg(r, g, b)
+      "\x1b[48;2;#{r};#{g};#{b}m"
+    end
+
+    def color_reset
+      "\x1b[0m"
+    end
+
+    def bold(text)
+      "\033[1m#{text}\033[0m"
+    end
+
+    def hosted_zone_to_struct(action, hosted_zone)
+      HostedZone.new(action, hosted_zone.name)
+    end
+
+    def entry_to_struct(action, entry, hosted_zone, parent_entry = nil)
+      type_highlight, name_highlight, value1_highlight, value2_highlight = if !parent_entry && ['+', '-'].include?(action)
+        [true, true, true, true]
+      else
+        [false, false, nil, nil]
+      end
+
+      action = case action
+      when 'u-'
+        '-'
+      when 'u+'
+        '+'
+      else
+        action
+      end
+
+      value1_highlight ||= if parent_entry
+        case parent_entry
+        when SprinkleDNS::HostedZoneEntry
+          parent_entry.changed_value
+        when SprinkleDNS::HostedZoneAlias
+          parent_entry.changed_target_hosted_zone_id
+        end
+      else
+        case entry
+        when SprinkleDNS::HostedZoneEntry
+          entry.changed_value
+        when SprinkleDNS::HostedZoneAlias
+          entry.changed_target_hosted_zone_id
+        end
+      end
+
+      value2_highlight ||= if parent_entry
+        case parent_entry
+        when SprinkleDNS::HostedZoneEntry
+          parent_entry.changed_ttl
+        when SprinkleDNS::HostedZoneAlias
+          parent_entry.changed_target_dns_name
+        end
+      else
+        case entry
+        when SprinkleDNS::HostedZoneEntry
+          entry.changed_ttl
+        when SprinkleDNS::HostedZoneAlias
+          entry.changed_target_dns_name
+        end
+      end
+
+      case entry
+      when SprinkleDNS::HostedZoneEntry
+        Entry.new(action,
+                  entry.type, type_highlight,
+                  entry.name, name_highlight,
+                  entry.value, value1_highlight,
+                  entry.ttl, value2_highlight,
+                  hosted_zone.name)
+      when SprinkleDNS::HostedZoneAlias
+        Entry.new(action,
+                  entry.type, type_highlight,
+                  entry.name, name_highlight,
+                  entry.target_hosted_zone_id, value1_highlight,
+                  entry.target_dns_name, value2_highlight,
+                  hosted_zone.name)
+      end
+    end
+  end
+end