path53 0.4.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 99b785b7695fe63239d1230482f5d81cef35094f
+  data.tar.gz: 7ae5a98ea8d3b1aad7f80f26f561a2bcb6279fc1
+SHA512:
+  metadata.gz: f8ead285292146d38902ac18c8423f17d5f8be25d2d23cad2ae2898e4a80cff33d7a67cb0c11f7b706eb6392516d91e89274cd743eb49236fc5ed3488032aa12
+  data.tar.gz: a216d96699d5d1c3879682d45b683233ca48fcca8e986f687f02c5053fdb576d68bc92c33c59de188e3aa290a7cc3ce91b80d4952e67ee3fc01e1ff39f37abb2

data/.gitignore

@@ -0,0 +1,54 @@
+
+# Created by https://www.gitignore.io/api/ruby
+
+### Ruby ###
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/LICENSE.txt

@@ -0,0 +1,21 @@
+
+The MIT License (MIT)
+Copyright © 2016 Chris Olstrom <chris@olstrom.com>
+
+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.org

@@ -0,0 +1,137 @@
+#+TITLE: Path53
+#+LATEX: \pagebreak
+
+* Overview
+
+=path53= provides a cleaner, simpler interface to Route53 change requests.
+
+* Why does this exist?
+
+Because making simple changes is unreasonably complicated. Route53's errors are
+generic, the request structure is a nested mess of complexity, and the
+validation rules are often surprising. =path53= aims to tame this complexity.
+
+* Installation
+
+#+BEGIN_SRC shell
+  gem install path53
+#+END_SRC
+
+* Usage
+
+First, we need to require it.
+
+#+BEGIN_SRC ruby
+  require 'path53'
+#+END_SRC
+
+We need a HostedZone to change. This can come from the Route53 API, but for the
+purposes of this example, we'll use a simple fixture.
+
+#+BEGIN_SRC ruby
+  Zone = Struct.new :id, :name
+  zone = Zone.new 'abc123', 'example.com.'
+#+END_SRC
+
+The primary feature of =path53= is changesets. Let's create one now:
+
+#+BEGIN_SRC ruby
+  changes = Path53::ChangeSet.new zone
+#+END_SRC
+
+With a changeset, we now create a batch of changes, using a block.
+
+#+BEGIN_SRC ruby
+  changes.batch do
+    add upsert a 'example.com', '127.0.0.1'
+    add upsert cname 'www.example.com.', 'example.com'
+  end
+#+END_SRC
+
+There's a fair bit going on in there, so let's have a look.
+
+~add~ says we want to add a change to this batch. ~remove~ would do the
+opposite.
+
+~upsert~ is what this change should do. ~create~, ~delete~, and ~upsert~ are all
+valid here.
+
+~a~ and ~cname~ describe the type of record we want to change. Any standard DNS
+record type would valid here.
+
+In the context of the ~a~ record, ~example.com~ refers to the name of the
+record, and ~127.0.0.1~ refers to the target of that record.
+
+Now that we have a batch of changes, simply call ~apply!~ to apply them.
+
+#+BEGIN_SRC ruby
+  changes.apply!
+#+END_SRC
+
+** Want more?
+
+As a convenient shorthand, you can do the following:
+
+#+BEGIN_SRC ruby
+  Path53.change(zone).batch { add upsert a 'www.example.com', '127.0.0.1' }.apply!
+#+END_SRC
+
+If you leave out an action, =path53= will assume you meant to ~upsert~.
+Therefore, this is equivalent to the previous example:
+
+#+BEGIN_SRC ruby
+  Path53.change(zone).batch { add a 'www.example.com', '127.0.0.1' }.apply!
+#+END_SRC
+
+=path53= plays nicely with =aws-sdk=. If you're working with ELBs for instance,
+you can pass a LoadBalancerDescription as a target, and =path53= will do the
+right thing. Therefore, the following is valid:
+
+#+BEGIN_SRC ruby
+  Path53.change(zone).batch { add a 'www.example.com', MyLoadBalancer }.apply!
+#+END_SRC
+
+Alias Targets are supported as well:
+
+#+BEGIN_SRC ruby
+  Path53.change(zone).batch { add a 'www.example.com', alias_target('zone_id', 'name') }.apply!
+#+END_SRC
+
+You may be wondering what's up with the ~remove~ method for changesets. Well, it
+turns out =path53= makes it really easy to cache things.
+
+#+BEGIN_SRC ruby
+  require 'yaml'
+
+  changes = Path53.change(zone).batch { add a 'www.example.com', '127.0.0.1' }
+
+  File.write 'saved-changes', YAML.dump(changes)
+
+  restored = YAML.load File.read 'saved-changes'
+  restored.apply!
+#+END_SRC
+
+This is useful when you have a changeset that is expensive to calculate, or you
+want to hold state for some reason.
+
+*** Even more?
+
+Most methods in =path53= support partial evaluation. The following is valid:
+
+#+BEGIN_SRC ruby
+  Path53.change(zone).batch do
+    www = a 'www.example.com'
+    add www.('127.0.0.1')
+  end
+#+END_SRC
+
+If for some reason you wanted to do that. It's pretty handy in an
+~each_with_object~ block, as an example.
+
+* License
+
+  ~path53~ is available under the [[https://tldrlegal.com/license/mit-license][MIT License]]. See ~LICENSE.txt~ for the full text.
+
+* Contributors
+
+  - [[https://colstrom.github.io/][Chris Olstrom]] | [[mailto:chris@olstrom.com][e-mail]] | [[https://twitter.com/ChrisOlstrom][Twitter]]

data/lib/path53/change_set.rb

@@ -0,0 +1,85 @@
+require 'aws-sdk'
+require 'contracts'
+require_relative 'features'
+
+module Path53
+  class ChangeSet
+    include ::Contracts::Core
+    include ::Contracts::Builtin
+    include ::Path53::Feature::AliasTargets
+    include ::Path53::Feature::Changes
+    include ::Path53::Feature::ResourceRecordSets
+
+    HostedZone = RespondTo[:id, :name]
+    ChangeRequest = ({
+                       hosted_zone_id: String,
+                       change_batch: {
+                         comment: Maybe[String],
+                         changes: ArrayOf[Change]
+                       }
+                     })
+
+    attr_reader :zone
+
+    Contract HostedZone => ChangeSet
+    def initialize(zone, changes = Set.new)
+      @zone = zone
+      @changes = changes
+      self
+    end
+
+    Contract Change => ChangeSet
+    def add(change)
+      @changes.add change
+      self
+    end
+
+    Contract BoundRecordSet => ChangeSet
+    def add(change)
+      @changes.add(*changes(change))
+      self
+    end
+
+    Contract Change => ChangeSet
+    def remove(change)
+      @changes.delete change
+      self
+    end
+
+    alias rem remove
+
+    Contract None => ChangeSet
+    def reset!
+      @changes = Set.new
+      self
+    end
+
+    Contract Proc => ChangeSet
+    def batch(&block)
+      self.tap do |this|
+        this.instance_eval(&block)
+      end
+    end
+
+    Contract None => String
+    def apply!
+      route53.change_resource_record_sets(self.to_request).change_info.id
+    end
+
+    Contract KeywordArgs[comment: Optional[String]] => ChangeRequest
+    def to_request(comment: nil)
+      {
+        hosted_zone_id: zone.id,
+        change_batch: {
+          changes: changes(@changes.to_a)
+        }.tap { |batch| batch.merge! comment: comment if comment }
+      }
+    end
+
+    private
+
+    def route53
+      @route53 ||= Aws::Route53::Client.new
+    end
+  end
+end

data/lib/path53/feature/alias_targets.rb

@@ -0,0 +1,56 @@
+require 'contracts'
+
+module Path53
+  module Feature
+    module AliasTargets
+      include ::Contracts::Core
+      include ::Contracts::Builtin
+
+      EvaluateTargetHealth = Or[
+        Bool,
+        KeywordArgs[evaluate_target_health: Bool],
+      ]
+
+      LoadBalancer = RespondTo[:canonical_hosted_zone_name_id, :canonical_hosted_zone_name]
+
+      AliasTarget = ({
+                       hosted_zone_id: String,
+                       dns_name: String,
+                       evaluate_target_health: Bool
+                     })
+
+      Contract None => Func[EvaluateTargetHealth => Bool]
+      def evaluate_target_health
+        ->(value) { evaluate_target_health value }
+      end
+
+      Contract Maybe[Bool] => Bool
+      def evaluate_target_health(value = false)
+        value || false
+      end
+
+      Contract KeywordArgs[evaluate_target_health: Bool] => Bool
+      def evaluate_target_health(options)
+        evaluate_target_health options.fetch :evaluate_target_health
+      end
+
+      Contract String, String, Maybe[EvaluateTargetHealth] => AliasTarget
+      def alias_target(zone, name, check = nil)
+        {
+          hosted_zone_id: zone,
+          dns_name: name,
+          evaluate_target_health: evaluate_target_health(check)
+        }
+      end
+
+      Contract LoadBalancer, Maybe[EvaluateTargetHealth] => AliasTarget
+      def alias_target(load_balancer, check = nil)
+        alias_target(
+          load_balancer.canonical_hosted_zone_name_id,
+          load_balancer.canonical_hosted_zone_name,
+          check
+        )
+      end
+    end
+  end
+end

data/lib/path53/feature/changes.rb

@@ -0,0 +1,59 @@
+require 'contracts'
+require_relative 'resource_record_sets'
+
+module Path53
+  module Feature
+    module Changes
+      include ::Contracts::Core
+      include ::Contracts::Builtin
+      include ::Path53::Feature::ResourceRecordSets
+
+      Action = Enum[*%w(CREATE DELETE UPSERT)]
+
+      Change = ({
+                  action: Action,
+                  resource_record_set: BoundRecordSet
+                })
+
+      ChangeContext = Func[BoundRecordSet => Change]
+
+      Contract ArrayOf[Change] => ArrayOf[Change]
+      def changes(changes)
+        changes
+      end
+
+      Contract ArrayOf[BoundRecordSet] => ArrayOf[Change]
+      def changes(changes)
+        changes.map { |change| upsert change }
+      end
+
+      Contract Or[Change, BoundRecordSet] => ArrayOf[Change]
+      def changes(change)
+        changes [change]
+      end
+
+      alias change changes
+
+      def self.included(_)
+        Action.instance_variable_get('@vals').each do |action|
+          define_method(action.downcase) { |*args| action(action, *args) }
+        end
+      end
+
+      private
+
+      Contract Action => ChangeContext
+      def action(action)
+        ->(record_set) { action action, record_set }
+      end
+
+      Contract Action, BoundRecordSet => Any
+      def action(action, record_set)
+        {
+          action: action,
+          resource_record_set: record_set
+        }
+      end
+    end
+  end
+end

data/lib/path53/feature/resource_record_sets.rb

@@ -0,0 +1,99 @@
+require 'contracts'
+require_relative 'alias_targets'
+
+module Path53
+  module Feature
+    module ResourceRecordSets
+      include ::Contracts::Core
+      include ::Contracts::Builtin
+      include ::Path53::Feature::AliasTargets
+
+      Type = Enum[*%w(A AAAA CNAME MX NAPTR NS PTR SOA SPF SRV TXT)]
+      TTL = Or[Integer, KeywordArgs[ttl: Integer]]
+      ResourceRecord = ({ value: String })
+
+      AliasRecordSet = ({ alias_target: AliasTarget })
+      ResourceRecordSet = ({
+                             resource_records: ArrayOf[ResourceRecord],
+                             ttl: Integer
+                           })
+
+      RecordSet = Or[ResourceRecordSet, AliasRecordSet]
+      Target = Xor[RecordSet, LoadBalancer, String]
+
+      BoundRecordSet = And[RecordSet, ({ name: String, type: Type })]
+
+      RecordContext = Func[Target => BoundRecordSet]
+      TypedContext = Func[String => RecordContext]
+
+      Contract None => Func[TTL => Integer]
+      def ttl
+        ->(value) { ttl value }
+      end
+
+      Contract Maybe[Integer] => Integer
+      def ttl(value = 300)
+        value || 300
+      end
+
+      Contract KeywordArgs[ttl: Integer] => Integer
+      def ttl(options)
+        ttl options.fetch :ttl
+      end
+
+      Contract ArrayOf[String], Maybe[TTL] => ResourceRecordSet
+      def record_set(targets, duration = nil)
+        {
+          ttl: ttl(duration),
+          resource_records: targets.map { |target| { value: name(target) } }
+        }
+      end
+
+      Contract String, Maybe[TTL] => ResourceRecordSet
+      def record_set(target, duration = nil)
+        record_set [target], duration
+      end
+
+      Contract AliasTarget, Maybe[TTL] => AliasRecordSet
+      def record_set(target, duration = nil)
+        { alias_target: target }
+      end
+
+      Contract LoadBalancer, Maybe[TTL] => AliasRecordSet
+      def record_set(load_balancer, duration = nil)
+        record_set alias_target load_balancer
+      end
+
+      def self.included(*)
+        Type.instance_variable_get('@vals').each do |t|
+          define_method(t.downcase) { |*args| type(t, *args) }
+        end
+      end
+
+      private
+
+      Contract String => String
+      def name(name)
+        name.gsub /\.@$/, ".#{zone.name}"
+      end
+
+      Contract Type => TypedContext
+      def type(type)
+        ->(name, target) { type type, name, target }
+      end
+
+      Contract Type, String => RecordContext
+      def type(type, name)
+        ->(target) { type type, name, target }
+      end
+
+      Contract Type, String, Target, Maybe[TTL] => BoundRecordSet
+      def type(type, name, target, duration = nil)
+        {
+          type: type,
+          name: name(name)
+        }.merge record_set(target, duration)
+      end
+    end
+  end
+end

data/lib/path53/features.rb

@@ -0,0 +1,3 @@
+require_relative 'feature/alias_targets'
+require_relative 'feature/changes'
+require_relative 'feature/resource_record_sets'

data/lib/path53.rb

@@ -0,0 +1,7 @@
+require_relative 'path53/change_set'
+
+module Path53
+  def self.change(zone)
+    ChangeSet.new(zone)
+  end
+end

data/path53.gemspec

@@ -0,0 +1,16 @@
+Gem::Specification.new do |gem|
+  gem.name        = 'path53'
+  gem.version     = `git describe --tags --abbrev=0`.chomp
+  gem.licenses    = 'MIT'
+  gem.authors     = ['Chris Olstrom']
+  gem.email       = 'chris@olstrom.com'
+  gem.homepage    = 'https://github.com/colstrom/path53'
+  gem.summary     = 'Simplified Changes for Route53'
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  gem.require_paths = ['lib']
+
+  gem.add_runtime_dependency 'aws-sdk', '~> 2.6', '>= 2.6.0'
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: path53
+version: !ruby/object:Gem::Version
+  version: 0.4.3
+platform: ruby
+authors:
+- Chris Olstrom
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.6.0
+description: 
+email: chris@olstrom.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- LICENSE.txt
+- README.org
+- lib/path53.rb
+- lib/path53/change_set.rb
+- lib/path53/feature/alias_targets.rb
+- lib/path53/feature/changes.rb
+- lib/path53/feature/resource_record_sets.rb
+- lib/path53/features.rb
+- path53.gemspec
+homepage: https://github.com/colstrom/path53
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.7
+signing_key: 
+specification_version: 4
+summary: Simplified Changes for Route53
+test_files: []