minidisc 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 772484f3ea8aabab0df47ecbdc0f750aa05a615c13deff11cbdaf5528207bac2
+  data.tar.gz: 8783d9fe8da2adbd5aacf4cf48e6523a64655c02dff60c1ec2d67f626c265eb3
+SHA512:
+  metadata.gz: 4b70e300ada3eb91ec7bbe32df10fd2c8cb3bb86f330e5adbd7c44414babed24246d1bd7bbe00d66f00be86d0256b6b5d231fa7d86717b8cc5cd2bacb2a58ad1
+  data.tar.gz: df8811859ef7ad5adf95294477a74ed0f0bf7d3426acca07734db79a58c787a33f4b65cc1e781caf3dfbcaa5405686241950be722c446c421640f028769090a5

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2017-2019 Ari Russo
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,48 @@
+# MiniDisc
+
+Mini service discovery in Ruby
+
+## Description
+
+I recently extracted MiniDisc from a personal project I've been working on. It offers a single line interface for common patterns in service discovery that I'd been redundantly implementing.
+
+Under the hood it wraps the DNSSD gem and is cross compatible with services using that.  It adds helpers for common tasks like matching services by name, dynamically overriding discovery, error handling, logging
+
+## Requirements
+
+### Linux
+
+* dns-sd
+* avahi 0.6.25+ (plus libavahi-compat-libdnssd-dev on Debian)
+
+## Usage
+
+To broadcast a service use something like:
+
+```ruby
+require "minidisc"
+
+MiniDisc::Registry.add(:http, 8080, id: "my-service-instance1")
+```
+
+To discover other services use
+
+```ruby
+MiniDisc::Discover.find_all(:http, id: /^my-service/) do |services|
+  ...
+end
+```
+
+## Installation
+
+`gem install minidisc`
+
+or when Bundler, add this to your Gemfile
+
+`gem "minidisc"`
+
+## License
+
+Apache 2.0, See LICENSE file
+
+Copyright (c) 2017-2019 [Ari Russo](http://arirusso.com)

data/lib/minidisc.rb

@@ -0,0 +1,12 @@
+require "dnssd"
+require "logger"
+
+require "minidisc/network"
+
+require "minidisc/service_type"
+require "minidisc/registry"
+require "minidisc/discover"
+
+module MiniDisc
+  VERSION = "0.0.4"
+end

data/lib/minidisc/discover.rb

@@ -0,0 +1,95 @@
+require "minidisc/discover/network"
+
+module MiniDisc
+
+  class Discover
+
+    class << self
+
+      def services(service_type, options = {}, &block)
+        ensure_initialized(options)
+        service_type = ServiceType.sym_to_dnnsd_string(service_type, options)
+        discover(service_type, options, &block)
+        @destinations
+      end
+
+      private
+
+      def ensure_initialized(options)
+        @logger ||= options[:logger] || Logger.new(STDOUT)
+        @destinations ||= []
+      end
+
+      def discover(service_type, options = {}, &block)
+        @destinations = if options[:override].nil?
+          from_discovery(service_type, id: options[:id], timeout: options[:timeout], &block)
+        else
+          from_override(options[:override], &block)
+        end
+      end
+
+      def from_override(services, &block)
+        i = 0;
+        service_objects = services.map do |service|
+          Service.new("override_#{i += 1}", service[:host], port: service[:port])
+        end
+        @logger.info("Destinations: Overriding discovery with #{services.count} services")
+        yield(service_objects) if block_given?
+        service_objects
+      end
+
+      def match?(match_on, service_name)
+        match_on.kind_of?(Regexp) && service_name.match(match_on) ||
+          match_on == service_name
+      end
+
+      def from_discovery(service_type, options = {}, &block)
+        services = Network.services_with_timeout(service_type, timeout: options[:timeout])
+        unless options[:id].nil?
+          services.select! do |service|
+            match?(options[:id], service[:name])
+          end
+        end
+        service_objects = service_hashes_to_service_objects(services)
+        @logger.info("Destinations: Discovered #{services.count} services")
+        yield(service_objects) if block_given?
+        service_objects
+      end
+
+      def service_hashes_to_service_objects(services)
+        services.map do |service|
+          Service.new(service[:name], service[:target], port: service[:port])
+        end
+      end
+
+    end
+
+    class Service
+
+      include Comparable
+
+      attr_reader :id, :host, :port
+
+      def initialize(id, host, options = {})
+        @id = id
+        @host = host
+        @port = options.fetch(:port, 8080)
+      end
+
+      def <=>(other)
+        to_h <=> other.to_h
+      end
+
+      def to_h
+        {
+          id: @id,
+          host: @host,
+          port: @port
+        }
+      end
+
+    end
+
+  end
+
+end

data/lib/minidisc/discover/network.rb

@@ -0,0 +1,59 @@
+require "timeout"
+
+module MiniDisc
+
+  class Discover
+
+    module Network
+
+      DEFAULT_TIMEOUT_LIMIT = 2
+
+      extend self
+
+      # @param [String] service_type with protocol eg "_telnet._tcp"
+      # @param [Hash] options
+      # @option options [Integer] :timeout Timeout in seconds
+      # @return [Array<Hash>]
+      def services_with_timeout(service_type, options = {}, &block)
+        timeout = options[:timeout] || DEFAULT_TIMEOUT_LIMIT
+        Timeout::timeout(timeout) do
+          result = services(service_type, &block)
+        end
+      rescue Timeout::Error => e
+        result = []
+      ensure
+        yield(result) if block_given?
+        result
+      end
+
+      # @param [String] service_type with protocol eg "_telnet._tcp"
+      # @return [Array<Hash>]
+      def services(service_type)
+        Thread.abort_on_exception = true
+        replies = {}
+        DNSSD.browse!(service_type) do |reply|
+          replies[reply.name] = reply
+          if !reply.flags.more_coming?
+            available_replies = replies.select do |_, service|
+              service.flags.add?
+            end
+            return available_replies.map do |_, service|
+              resolve = service.resolve
+              {
+                name: service.name,
+                target: resolve.target,
+                port: resolve.port
+              }
+            end
+          end
+
+        end
+      rescue Errno::EBADF, DNSSD::ServiceNotRunningError
+        []
+      end
+
+    end
+
+  end
+
+end

data/lib/minidisc/network.rb

@@ -0,0 +1,15 @@
+module MiniDisc
+  module Network
+
+    extend self
+
+    def add(*a, &block)
+      Registry.add(*a, &block)
+    end
+
+    def find_all(*a, &block)
+      Discover.services(*a, &block)
+    end
+
+  end
+end

data/lib/minidisc/registry.rb

@@ -0,0 +1,56 @@
+module MiniDisc
+
+  module Registry
+
+    # Register a service
+    # @param [Integer] port
+    # @return [Discovery]
+    def self.add(service_type, port, options = {})
+      ensure_logger
+      @services ||= []
+      service = Registry::Service.new(service_type, port, options)
+      service.register(logger: @logger)
+      @services << service
+      service
+    end
+
+    private
+
+    def self.ensure_logger(options = {})
+      @logger ||= options[:logger] || Logger.new(STDOUT)
+    end
+
+    class Service
+
+      attr_reader :id, :logger, :port
+
+      # @param [Symbol] service_type eg :telnet
+      # @param [Integer] port
+      def initialize(service_type, port, options = {})
+        @id = options.fetch(:id, object_id.to_s)
+        @port = port
+        @service_type = ServiceType.sym_to_dnnsd_string(service_type, options)
+      end
+
+      def registered?
+        @registered
+      end
+
+      # Register this service
+      # @return [Boolean]
+      def register(options = {})
+        DNSSD.register(@id, @service_type, nil, @port) do
+          properties = "id=#{@id} port=#{@port} service_type=#{@service_type}"
+          unless options[:logger].nil?
+            options[:logger].info("MiniDisc::Registry::Service#register: #{properties}")
+          end
+        end
+        @registered = true
+      rescue Errno::EBADF
+        @registered = false
+      end
+
+    end
+
+  end
+end

data/lib/minidisc/service_type.rb

@@ -0,0 +1,13 @@
+module MiniDisc
+
+  module ServiceType
+
+    def self.sym_to_dnnsd_string(service_type, options = {})
+      protocol = options.fetch(:protocol, :tcp).to_s
+      protocol.gsub!(/\_/, "-")
+      "_#{service_type}._#{protocol}"
+    end
+
+  end
+
+end

data/spec/discover/network_spec.rb

@@ -0,0 +1,47 @@
+require "helper"
+
+describe MiniDisc::Discover::Network do
+  describe "services_with_timeout" do
+    let!(:start_time) { Time.now }
+    let(:block) do
+      ->(service_type) do
+        loop {}
+        :done
+      end
+    end
+
+    before do
+      expect(MiniDisc::Discover::Network).to(receive(:services, &block))
+    end
+
+    context "with block" do
+
+      before do
+        MiniDisc::Discover::Network.services_with_timeout(:http) do |result|
+          @result = result
+        end
+      end
+
+      it "times out and returns empty array" do
+        expect(@result).to_not(eql(:done))
+        expect(@result).to(be_kind_of(Array))
+        expect(@result).to(be_empty)
+      end
+
+    end
+
+    context "without block" do
+
+      before do
+        @result = MiniDisc::Discover::Network.services_with_timeout(:http)
+      end
+
+      it "times out and returns empty array" do
+        expect(@result).to_not(eql(:done))
+        expect(@result).to(be_kind_of(Array))
+        expect(@result).to(be_empty)
+      end
+
+    end
+  end
+end

data/spec/discover_spec.rb

@@ -0,0 +1,120 @@
+require "helper"
+
+describe MiniDisc::Discover do
+  describe ".services" do
+
+    context "from override file" do
+      let(:host) { "something.local." }
+      let(:port) { "80" }
+      let(:config_service) do
+        {
+          host: host,
+          port: port
+        }
+      end
+
+      let(:destinations) do
+         MiniDisc::Discover.services(:http, override: [config_service])
+      end
+
+      it "populates" do
+        expect(destinations).to_not(be_nil)
+        expect(destinations).to_not(be_empty)
+      end
+
+      it "has correct data" do
+        expect(destinations.count).to(eq(1))
+        destination = destinations.first
+        expect(destination).to(be_kind_of(MiniDisc::Discover::Service))
+        expect(destination.id).to(eq("override_1"))
+        expect(destination.host).to(eq(host))
+        expect(destination.port).to(eq(port))
+      end
+    end
+
+    context "from discovery" do
+      let(:name) { "minidisc-test_service" }
+      let(:host) { "testservice.local." }
+      let(:port) { "8080" }
+      let(:service) do
+        {
+          name: name,
+          target: host,
+          port: port
+        }
+      end
+
+      before(:each) do
+        expect(MiniDisc::Discover::Network).to(receive(:services_with_timeout).at_least(:once).and_return([service]))
+      end
+
+      context "with id matching" do
+        let(:destinations) do
+          MiniDisc::Discover.services(:http, match: /minidisc\-.+/)
+        end
+
+        it "populates" do
+          expect(destinations).to_not(be_nil)
+          expect(destinations).to_not(be_empty)
+        end
+
+        it "has correct data" do
+          expect(destinations.count).to(eq(1))
+          destination = destinations.first
+          expect(destination).to(be_kind_of(MiniDisc::Discover::Service))
+          expect(destination.id).to(eq(name))
+          expect(destination.host).to(eq(host))
+          expect(destination.port).to(eq(port))
+        end
+      end
+
+      context "without id matching" do
+        let(:destinations) { MiniDisc::Discover.services(:http) }
+
+        it "populates" do
+          expect(destinations).to_not(be_nil)
+          expect(destinations).to_not(be_empty)
+        end
+
+        it "has correct data" do
+          expect(destinations.count).to(eq(1))
+          destination = destinations.first
+          expect(destination).to(be_kind_of(MiniDisc::Discover::Service))
+          expect(destination.id).to(eq(name))
+          expect(destination.host).to(eq(host))
+          expect(destination.port).to(eq(port))
+        end
+      end
+    end
+  end
+
+  describe "#to_h" do
+    let(:id) { "minidisc-test" }
+    let(:host) { "test.local." }
+    let(:port) { 8000 }
+    let(:destination) do
+      MiniDisc::Discover::Service.new(id, host, port: port)
+    end
+    let(:hash) { destination.to_h }
+
+    it "converts to hash" do
+      expect(hash).to_not(be_nil)
+      expect(hash).to(be_kind_of(Hash))
+      expect(hash[:id]).to_not(be_nil)
+      expect(hash[:host]).to_not(be_nil)
+      expect(hash[:port]).to_not(be_nil)
+    end
+
+    it "matches object" do
+      expect(hash[:id]).to(eq(destination.id))
+      expect(hash[:host]).to(eq(destination.host))
+      expect(hash[:port]).to(eq(destination.port))
+    end
+
+    it "has correct data" do
+      expect(hash[:id]).to(eq(id))
+      expect(hash[:host]).to(eq(host))
+      expect(hash[:port]).to(eq(port))
+    end
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,4 @@
+$:.unshift(File.join("..", "lib"))
+
+require "rspec"
+require "minidisc"

data/spec/network_spec.rb

@@ -0,0 +1,111 @@
+require "helper"
+
+describe MiniDisc::Network do
+  describe ".add" do
+    let(:port) { 4040 }
+    let(:service_type) { :http }
+
+    describe "#register" do
+      let(:args) do
+        [kind_of(String), "_http._tcp", nil, port]
+      end
+
+      before(:each) do
+        expect(DNSSD).to(receive(:register).with(*args).and_return(true))
+      end
+
+      it "registers" do
+        service = MiniDisc::Network.add(service_type, port)
+        expect(service.registered?).to(be(true))
+      end
+    end
+
+  end
+
+  describe ".find_all" do
+
+    context "from override file" do
+      let(:host) { "something.local." }
+      let(:port) { "80" }
+      let(:config_service) do
+        {
+          host: host,
+          port: port
+        }
+      end
+
+      let(:destinations) do
+         MiniDisc::Network.find_all(:http, override: [config_service])
+      end
+
+      it "populates" do
+        expect(destinations).to_not(be_nil)
+        expect(destinations).to_not(be_empty)
+      end
+
+      it "has correct data" do
+        expect(destinations.count).to(eq(1))
+        destination = destinations.first
+        expect(destination).to(be_kind_of(MiniDisc::Discover::Service))
+        expect(destination.id).to(eq("override_1"))
+        expect(destination.host).to(eq(host))
+        expect(destination.port).to(eq(port))
+      end
+    end
+
+    context "from discovery" do
+      let(:name) { "minidisc-test_service" }
+      let(:host) { "testservice.local." }
+      let(:port) { "8080" }
+      let(:service) do
+        {
+          name: name,
+          target: host,
+          port: port
+        }
+      end
+
+      before(:each) do
+        expect(MiniDisc::Discover::Network).to(receive(:services_with_timeout).at_least(:once).and_return([service]))
+      end
+
+      context "with id matching" do
+        let(:destinations) do
+          MiniDisc::Network.find_all(:http, match: /minidisc\-.+/)
+        end
+
+        it "populates" do
+          expect(destinations).to_not(be_nil)
+          expect(destinations).to_not(be_empty)
+        end
+
+        it "has correct data" do
+          expect(destinations.count).to(eq(1))
+          destination = destinations.first
+          expect(destination).to(be_kind_of(MiniDisc::Discover::Service))
+          expect(destination.id).to(eq(name))
+          expect(destination.host).to(eq(host))
+          expect(destination.port).to(eq(port))
+        end
+      end
+
+      context "without id matching" do
+        let(:destinations) { MiniDisc::Discover.services(:http) }
+
+        it "populates" do
+          expect(destinations).to_not(be_nil)
+          expect(destinations).to_not(be_empty)
+        end
+
+        it "has correct data" do
+          expect(destinations.count).to(eq(1))
+          destination = destinations.first
+          expect(destination).to(be_kind_of(MiniDisc::Discover::Service))
+          expect(destination.id).to(eq(name))
+          expect(destination.host).to(eq(host))
+          expect(destination.port).to(eq(port))
+        end
+      end
+    end
+  end
+end

data/spec/registry_spec.rb

@@ -0,0 +1,84 @@
+require "helper"
+
+describe MiniDisc::Registry do
+  let(:id) { "test-1"}
+  let(:port) { 4040 }
+  let(:service_type) { :http }
+
+  describe ".add" do
+    describe "with id specified" do
+      let(:discovery) { MiniDisc::Registry.add(service_type, port, id: id) }
+
+      it "populates" do
+        expect(discovery.id).to_not(be_nil)
+        expect(discovery.port).to_not(be_nil)
+      end
+
+      it "has correct values" do
+        expect(discovery.id).to(eq(id))
+        expect(discovery.port).to(eq(port))
+      end
+    end
+
+    describe "with id not specified" do
+      let(:discovery) { MiniDisc::Registry.add(service_type, port) }
+
+      it "populates" do
+        expect(discovery.id).to_not(be_nil)
+        expect(discovery.port).to_not(be_nil)
+      end
+
+      it "has correct values" do
+        expect(discovery.id).to(include(discovery.object_id.to_s))
+        expect(discovery.port).to(eq(port))
+      end
+    end
+  end
+
+  describe "Service" do
+    describe "#initialize" do
+      describe "with id specified" do
+        let(:discovery) { MiniDisc::Registry::Service.new(service_type, port, id: id) }
+
+        it "populates" do
+          expect(discovery.id).to_not(be_nil)
+          expect(discovery.port).to_not(be_nil)
+        end
+
+        it "has correct values" do
+          expect(discovery.id).to(eq(id))
+          expect(discovery.port).to(eq(port))
+        end
+      end
+
+      describe "with id not specified" do
+        let(:discovery) { MiniDisc::Registry::Service.new(service_type, port) }
+
+        it "populates" do
+          expect(discovery.id).to_not(be_nil)
+          expect(discovery.port).to_not(be_nil)
+        end
+
+        it "has correct values" do
+          expect(discovery.id).to(include(discovery.object_id.to_s))
+          expect(discovery.port).to(eq(port))
+        end
+      end
+    end
+
+    describe "#register" do
+      let(:discovery) { MiniDisc::Registry::Service.new(service_type, port) }
+      let(:args) do
+        [discovery.id, "_http._tcp", nil, port]
+      end
+
+      before(:each) do
+        expect(DNSSD).to(receive(:register).with(*args).and_return(true))
+      end
+
+      it "registers and returns true" do
+        expect(discovery.register).to(be(true))
+      end
+    end
+  end
+end

data/spec/service_type_spec.rb

@@ -0,0 +1,27 @@
+require "helper"
+
+describe MiniDisc::ServiceType do
+  describe "#sym_to_dnnsd_string" do
+    context "without protocol" do
+      let(:input) { :http }
+      let(:result) { MiniDisc::ServiceType.sym_to_dnnsd_string(:http) }
+
+      it "has the correct service type part and tcp as defult protocol part" do
+        expect(result).to(eq("_http._tcp"))
+      end
+
+    end
+
+    context "with protocol" do
+      let(:input) { :example }
+      let(:protocol) { :udp }
+      let(:result) { MiniDisc::ServiceType.sym_to_dnnsd_string(input, protocol: protocol) }
+
+      it "reflects when udp is passed in" do
+        expect(result).to(eq("_example._udp"))
+      end
+
+    end
+
+  end
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: minidisc
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- Ari Russo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-03-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dnssd
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+description: Mini service discovery
+email:
+- ari.russo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/minidisc.rb
+- lib/minidisc/discover.rb
+- lib/minidisc/discover/network.rb
+- lib/minidisc/network.rb
+- lib/minidisc/registry.rb
+- lib/minidisc/service_type.rb
+- spec/discover/network_spec.rb
+- spec/discover_spec.rb
+- spec/helper.rb
+- spec/network_spec.rb
+- spec/registry_spec.rb
+- spec/service_type_spec.rb
+homepage: http://github.com/arirusso/minidisc
+licenses:
+- Apache-2.0
+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: 1.3.6
+requirements: []
+rubygems_version: 3.0.1
+signing_key: 
+specification_version: 4
+summary: Mini service discovery
+test_files: []