active_zone 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5883915c05075277429a22c1be2faa60d1b0e9b2a9dcff61f631589ed60c7d0c
+  data.tar.gz: 4d31ca5a2f065943356905f5f142d89ada3ac43a9e2468ec0f9c020df2a4fe9b
+SHA512:
+  metadata.gz: d724771b2abf9bd36a2280ac1ae7d90df0cbc4c5305c08d74285ea527856f2adb82fef47f866dbd8d9fa209a59a8fa3dc8bde711fe403251c4d4894ef531e4f5
+  data.tar.gz: e1bfe415fc7a9d37ca0c834bbefb34fd461fc1793dd23e9fa101f9c6301ccaed205c79ee4344970136baffb2f01e4aa2943b02a230c42d071b93ef834ba3678b

data/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright Obl.ong
+
+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,28 @@
+# Active Zone
+A Rails engine for managing database-backed DNS zones with various nameserver adapters.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "active_zone"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install active_zone
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT), and aims to remain compatible with the [Ruby on Rails](https://github.com/rails/rails) licensing terms.

data/Rakefile

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

data/config/initializers/provider.rb

@@ -0,0 +1 @@
+ActiveZone.provider = RactorDNS::ActiveZone.new(cpu_count: 24, zones: {})

data/lib/active_zone/provider/zone.rb

@@ -0,0 +1,77 @@
+module ActiveZone
+  # An Active Model class representing a DNS Zone at a provider.
+  # @abstract Subclass and override to create a functional Zone model
+  # @see Zone
+  # @see Zone::Builtins
+  class Provider::Zone
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+    include ActiveModel::AttributeAssignment
+    include ActiveModel::Dirty
+    include ActiveModel::Conversion
+    include ActiveModel::Serialization
+    include ActiveModel::Validations
+    extend ActiveModel::Callbacks
+    include ActiveZone::Zone::Builtins
+
+    # Whether the current zone is persisted with a provider
+    # @api private
+    # @macro boolean
+    attr_reader :persisted
+
+    # @param provider [ActiveZone::Provider] Provider to store the zone with
+    # @param attributes [Hash] Attributes for the zone
+    # @option attributes [Array] :resources Array of resources mappable to {ActiveZone::Resource}
+    # @option attributes [String] :name Name of the zone
+    # @option attributes [TrueClass, FalseClass] :persisted Whether the zone is persisted at the provider
+    def initialize(provider = ActiveZone.provider, **attributes)
+      @provider = provider
+      (attributes[:resources] = attributes[:resources].map { |el| ActiveZone::Resource.new(**el) }) if attributes[:resources]
+      super(attributes)
+      clear_changes_information
+    end
+
+    # Delegate missing class methods to {all}
+    def self.method_missing(method_name, *, &)
+      all.send(method_name, *, &)
+    end
+
+    # (see method_missing)
+    # @macro boolean
+    def self.respond_to_missing?(method_name, include_private = false)
+      all.respond_to?(method_name, include_private)
+    end
+
+    attribute :name, :string, default: ""
+    attribute :persisted, default: false
+    attribute :resources, array: true, default: []
+    define_attribute_methods :name, :resources
+    # Provider the zone will be stored at
+    # @return [ActiveZone::Provider]
+    attr_reader :provider
+
+    define_model_callbacks :create, :save, :destroy
+
+    # Underlying method to save the current zone
+    # @api private
+    # @abstract Override in subclass with how to persist a Zone at your provider
+    # @macro boolean
+    def persist!(**options, &block)
+      raise NotImplementedError
+    end
+
+    # Underlying method to delete the current zone
+    # @api private
+    # @abstract Override in subclass with how to delete a Zone at your provider.
+    # @macro boolean
+    def delete!
+      raise NotImplementedError
+    end
+
+    # (see persisted)
+    # @see persisted
+    def persisted?
+      persisted
+    end
+  end
+end

data/lib/active_zone/provider/zone_collection.rb

@@ -0,0 +1,80 @@
+module ActiveZone
+  # A queryable array-like class representing a collection of {Zone} at a provider
+  # @see https://edgeapi.rubyonrails.org/classes/ActiveRecord/Relation.html
+  # @abstract Subclass and override to create a queryable zone collection
+  class Provider::ZoneCollection
+    include Enumerable
+    # Provider the ZoneCollection is bound to
+    # @return [Provider]
+    attr_reader :provider
+    # Set of names in the ZoneCollection
+    # @return [Array]
+    # @return [nil] if all zones is desired
+    attr_accessor :set
+
+    # Initialize new ZoneCollection
+    # @param provider [ActiveZone::Provider] the provider
+    # @param set [Array] Array of names in the ZoneCollection, or nil for all zones
+    # @return ActiveZone::Provider::ZoneCollection
+    def initialize(provider, set = nil)
+      @provider = provider
+      @set = set
+    end
+
+    # Iterate over the zones at the provider
+    # @abstract Override and yield all zones in the set at the provider
+    # @yield [Zone] Zones within the {set} at the provider
+    # @raise {NotImplementedError}
+    def each(&block)
+      raise NotImplementedError
+    end
+
+    # Destroy all zones in this collection
+    # @return {nil}
+    # @abstract Override and destroy all zones in the set at the provider
+    # @raise {NotImplementedError}
+    def destroy_all
+      raise NotImplementedError
+    end
+
+    # Find a zone by name
+    # @return {Zone}
+    # @abstract Override and find the first zone by name in the set at the provider
+    # @raise {NotImplementedError}
+    def find(name)
+      raise NotImplementedError
+    end
+
+    # Find a zone by attribute in this collection
+    # @param attributes [Hash] attributes to filter by
+    # @return {Zone}
+    # @abstract Override and find the first zone that matches the provided attributes in the set at the provider
+    # @raise {NotImplementedError}
+    def find_by(**attributes)
+      raise NotImplementedError
+    end
+
+    # Find a zone by name inside this collection, if not found then create it
+    # @param attributes [Hash] the attributes of the zone to find by or create with
+    # @return {Zone}
+    def find_or_create_by(**attributes)
+      find_by(attributes) || provider.Zone.create(attributes)
+    end
+
+    # Update a zone by name in this collection, if not found then create it
+    # @param name [String] the name of the zone
+    # @return {Zone}
+    def upsert(name)
+      z = find_or_create_by(name:)
+      z.update(attributes)
+    end
+
+    # Get nth value in collection
+    # @abstract Override and get the nth value in the set at the provider
+    # @raise {NotImplementedError}
+    # @return {Zone}
+    def [](i)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/active_zone/provider.rb

@@ -0,0 +1,19 @@
+module ActiveZone
+  # The base class for Active Zone providers
+  # @abstract Subclass in your provider gem.
+  # @!method initialize(**options)
+  #   @abstract Override in your provider subclass to configure & initialize your provider.
+  #   @example Rails initializer
+  #     ActiveZone.provider = YourProvider.new(username:, password:, base_url: "dns.example.com")
+  class Provider
+    # @return [Object<Zone>] Zone constant scoped under this Provider
+    def Zone
+      self.class.const_get(:Zone)
+    end
+
+    # @return [Object<ZoneCollection>] ZoneCollection constant scoped under this Provider
+    def ZoneCollection
+      self.class.const_get(:ZoneCollection)
+    end
+  end
+end

data/lib/active_zone/resource.rb

@@ -0,0 +1,44 @@
+# Simple wrapper for a complete resource
+class ActiveZone::Resource
+  # @return [String]
+  attr_reader :name
+  # @return [Integer]
+  attr_reader :ttl
+  # @return [RRs::Resource]
+  attr_reader :rr
+
+  def initialize(zone: nil, name: "", ttl: 300, rr: nil)
+    @zone = zone
+    @name = name
+    @ttl = ttl
+    @rr = rr
+    @zone&.resources_will_change!
+  end
+
+  # Set name and mark changed on zone
+  # @param v [String]
+  def name=(v)
+    @name = v
+    @zone&.resources_will_change!
+  end
+
+  # Set TTL and mark changed on zone
+  # @param v [Integer]
+  def ttl=(v)
+    @ttl = v
+    @zone&.resources_will_change!
+  end
+
+  # Set RR and mark changed on zone
+  # @param v [RRs::Resource]
+  def rr=(v)
+    @rr = v
+    @zone&.resources_will_change!
+  end
+
+  # Convert to hash
+  # @return [Hash]
+  def to_h
+    {name:, ttl:, rr:}
+  end
+end

data/lib/active_zone/version.rb

@@ -0,0 +1,5 @@
+module ActiveZone
+  # Version of the gem
+  # @return [String]
+  VERSION = "0.2.1"
+end

data/lib/active_zone/zone/builtins/persistence.rb

@@ -0,0 +1,147 @@
+module ActiveZone::Zone::Builtins
+  # Adds Active Record-like persistence methods to {ActiveZone::Provider::Zone}
+  # @see https://edgeapi.rubyonrails.org/classes/ActiveRecord/Persistence.html
+  module Persistence
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # Creates and persists a {ActiveZone::Provider::Zone} without raising errors
+      # @return [ActiveZone::Provider::Zone]
+      # @return [FalseClass] if errored out
+      def create(attributes = nil, &block)
+        run_callbacks(:create) do
+          if attributes.is_a?(Array)
+            attributes.collect { |attr| create(attr, &block) }
+          else
+            object = new(attributes, &block)
+            object.save
+            object
+          end
+        end
+      end
+
+      # Creates and persists a {ActiveZone::Provider::Zone} and raises an error on failure
+      # @raise (see #save!)
+      # @return [ActiveZone::Provider::Zone]
+      def create!(attributes = nil, &block)
+        run_callbacks(:create) do
+          if attributes.is_a?(Array)
+            attributes.collect { |attr| create!(attr, &block) }
+          else
+            object = new(attributes, &block)
+            object.save!
+            object
+          end
+        end
+      end
+
+      # Bulk update attributes on a set of {ActiveZone::Provider::Zone}
+      # @return {ActiveZone::Provider::ZoneCollection}
+      # @return {ActiveZone::Provider::Zone}
+      # @return [FalseClass] if errored out
+      def update(name = :all, **attributes)
+        if name.is_a?(Array)
+          if name.any?(ActiveZone::Provider::Zone)
+            raise ArgumentError,
+              "You are passing an array of Zone instances to `update`. " \
+              "Please pass the names of the objects by calling `pluck(:name)` or `map(&:name)`."
+          end
+          name.map { |one_name| find(one_name) }.each_with_index { |object, namex|
+            object.update(attributes[namex])
+          }
+        elsif name == :all
+          all.each { |record| record.update(attributes) }
+        else
+          if name.is_a? ActiveZone::Provider::Zone
+            raise ArgumentError,
+              "You are passing an instance of Zone to `update`. " \
+              "Please pass the name of the object by calling `.name`."
+          end
+          object = find(name)
+          object.update(attributes)
+          object
+        end
+      end
+
+      # Bulk update attributes on a set of {ActiveZone::Provider::Zone} and raise errors on failure
+      # @return {ActiveZone::Provider::ZoneCollection}
+      # @return {ActiveZone::Provider::Zone}
+      # @raise (see Persistence#update!)
+      def update!(name = :all, **attributes)
+        if name.is_a?(Array)
+          if name.any?(ActiveZone::Provider::Zone)
+            raise ArgumentError,
+              "You are passing an array of Zone instances to `update!`. " \
+              "Please pass the ids of the objects by calling `pluck(:name)` or `map(&:name)`."
+          end
+          name.map { |one_name| find(one_name) }.each_with_index { |object, idx|
+            object.update!(attributes[idx])
+          }
+        elsif name == :all
+          all.each { |record| record.update!(attributes) }
+        else
+          if name.is_a? ActiveZone::Provider::Zone
+            raise ArgumentError,
+              "You are passing an instance of Zone to `update!`. " \
+              "Please pass the name of the object by calling `.name`."
+          end
+          object = find(name)
+          object.update!(attributes)
+          object
+        end
+      end
+    end
+
+    # Persists a {ActiveZone::Provider::Zone}
+    # @return [ActiveZone::Provider::Zone]
+    # @return [FalseClass] if errored out
+    def save(**options, &block)
+      run_callbacks(:save) do
+        persist!
+      end
+      self
+    rescue
+      false
+    end
+
+    # Persists a {ActiveZone::Provider::Zone} and raises an error on failure
+    # @raise {RuntimeError}
+    # @return [ActiveZone::Provider::Zone]
+    def save!(**, &)
+      save(**, &) || raise("Failed to save the zone")
+    end
+
+    # Destroys a {ActiveZone::Provider::Zone} at the provider and freezes the {Provider::Zone}
+    # @macro boolean
+    def destroy
+      run_callbacks(:destroy) do
+        delete! if persisted?
+        freeze
+      end
+      true
+    rescue
+      false
+    end
+
+    # Destroys a {ActiveZone::Provider::Zone} at the provider, freezes the {Provider::Zone} and raises errors on failure
+    # @return {TrueClass}
+    # @raise {RuntimeError}
+    def destroy!
+      destroy || raise("Failed to destroy the zone")
+    end
+
+    # Updates attributes of a {ActiveZone::Provider::Zone} and saves it
+    # @return (see #save)
+    def update(attributes)
+      assign_attributes(attributes)
+      save
+    end
+
+    # Updates attributes of a {ActiveZone::Provider::Zone}, saves it and raises errors on failure
+    # @return (see #save)
+    # @raise {RuntimeError}
+    def update!(attributes)
+      update || raise("Failed to update the zone")
+    end
+  end
+end

data/lib/active_zone/zone/builtins.rb

@@ -0,0 +1,36 @@
+# A module of builtins for {ActiveZone::Provider::Zone}
+module ActiveZone::Zone::Builtins
+  include Persistence
+  extend ActiveSupport::Concern
+
+  class_methods do
+    # @!scope class
+
+    @@provider = nil
+    @@semaphore = Mutex.new
+
+    # @return [ActiveZone::Provider]
+    # @api private
+    # Current provider in use for class methods, set dynamically by {with_provider}
+    attr_reader :provider
+    # @return [Mutex]
+    # @api private
+    # Used to lock current provider for class methods in {with_provider}
+    attr_reader :semaphore
+
+    # Locks the {ActiveZone::Provider} used in {ActiveZone::Provider::Zone} class methods and executes the block
+    def with_provider(provider, &block)
+      @@semaphore.synchronize {
+        @@provider = provider
+        val = block.call(self)
+        @@provider = nil
+        return val
+      }
+    end
+
+    # @return {Provider::ZoneCollection} for all zones at the current {Provider}
+    def all
+      @@provider&.ZoneCollection&.new(@@provider, nil)
+    end
+  end
+end

data/lib/active_zone/zone.rb

@@ -0,0 +1,32 @@
+# Proxy class for easily accessing {Provider::Zone} at the current {Provider}
+# @see ActiveZone::Provider::Zone
+class ActiveZone::Zone
+  # @param attributes [Hash] attributes for the new {Provider::Zone}
+  def initialize(**attributes)
+    @zone = ActiveZone.provider.Zone.new(**attributes)
+  end
+
+  # Delegate to {Provider::Zone}
+  def method_missing(method_name, *, &)
+    @zone.send(method_name, *, &)
+  end
+
+  # Delegate to {Provider::Zone}
+  # @macro boolean
+  def respond_to_missing?(method_name, include_private = false)
+    @zone.respond_to?(method_name, include_private)
+  end
+
+  # Delegate class methods to current [Provider::Zone]
+  def self.method_missing(method_name, *arguments, &block)
+    ActiveZone.provider.Zone.with_provider(ActiveZone.provider) do |z|
+      z.send(method_name, *arguments, &block)
+    end
+  end
+
+  # Delegate class methods to current [Provider::Zone]
+  # @macro boolean
+  def self.respond_to_missing?(method_name, include_private = false)
+    ActiveZone.provider.Zone.respond_to?(method_name, include_private)
+  end
+end

data/lib/active_zone.rb

@@ -0,0 +1,18 @@
+require "active_support/all"
+require "rrs"
+require "ractor_dns"
+require "zeitwerk"
+
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+
+# Base Active Zone module
+module ActiveZone
+  # Current default provider
+  # @return [Provider]
+  mattr_accessor :provider
+end
+
+# @!macro [new] boolean
+#   @return [TrueClass] if true
+#   @return [FalseClass] if false

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: active_zone
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Obl.ong
+- Reese Armstrong
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-08-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.2.0
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: rrs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+description: A Rails engine for managing database-backed DNS zones with various nameserver
+  adapters.
+email:
+- team@obl.ong
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- README.md
+- Rakefile
+- config/initializers/provider.rb
+- lib/active_zone.rb
+- lib/active_zone/provider.rb
+- lib/active_zone/provider/zone.rb
+- lib/active_zone/provider/zone_collection.rb
+- lib/active_zone/resource.rb
+- lib/active_zone/version.rb
+- lib/active_zone/zone.rb
+- lib/active_zone/zone/builtins.rb
+- lib/active_zone/zone/builtins/persistence.rb
+homepage: https://github.com/obl-ong/active_zone
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/obl-ong/active_zone
+  source_code_uri: https://github.com/obl-ong/active_zone
+  changelog_uri: https://github.com/obl-ong/active_zone/releases
+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: []
+rubygems_version: 3.5.17
+signing_key:
+specification_version: 4
+summary: Manage database-backed DNS zones with Rails
+test_files: []