zt 0.1.1

data/lib/zt/constants.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'xdg'
+
+module Zt
+  module Constants
+    ALL_EXPORTERS = %w[
+      HostsFileExporter
+    ].freeze
+    ALL_IMPORTERS = %w[
+      NetworkImporter
+      NodeImporter
+    ].freeze
+    AUTH_TOKEN_LENGTH = 32
+    AUTH_TOKEN_REGEX = /^[A-Za-z0-9]+$/.freeze
+    CONF_DIR = "#{XDG['CONFIG_HOME']}/zt"
+    CONF_SECTIONS = {
+      domains: 'domains.yaml',
+      networks: 'networks.yaml',
+      nodes: 'nodes.yaml',
+      zt: 'zt.conf.yaml'
+    }.freeze
+    # noinspection RubyStringKeysInHashInspection
+    INITIAL_CONF = {
+      'nodes.yaml' => {
+        'node_id' => {
+          'hostname' => 'node-hostname',
+          'networks' => %w[network_id_1 network_id_2]
+        }
+      },
+      'networks.yaml' => {
+        'network_id' => {
+          'name' => 'network_name'
+        }
+      },
+      'domains.yaml' => {
+        'network_id' => 'domain-name.zt'
+      },
+      'zt.conf.yaml' => {
+        'manual_pulls' => false,
+        'token' => 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',
+        'top_level_domain' => 'zt'
+      }
+    }.freeze
+  end
+end

data/lib/zt/errors.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'zt/errors/conf_errors'

data/lib/zt/errors/conf_errors.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Zt
+  module Errors
+    # Config does not exist on disk and cannot be created
+    class ZtConfDiskError < StandardError
+      def initialize
+        super
+      end
+    end
+
+    # Config exists on disk but cannot be parsed
+    class ZtConfSyntaxError < StandardError
+      def initialize
+        super
+      end
+    end
+
+    # Invalid section specifier for config
+    class ZtConfInvalidSectionError < StandardError
+      def initialize
+        super
+      end
+    end
+  end
+end

data/lib/zt/exporters.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'zt/constants'
+require 'zt/exporters/_base_exporter'
+require 'zt/exporters/hosts_file_exporter'
+
+module Zt
+  module Exporters
+    class Exporter
+      def initialize(*exporter_names)
+        exporter_names = Zt::Constants::ALL_EXPORTERS if exporter_names.empty?
+
+        exporter_classes = exporter_names.map { |n| Zt::Exporters.const_get(n) }
+        @exporters = exporter_classes.map(&:new)
+      end
+
+      # @return [Array[Hash]] an array of hashes from each exporter
+      # The hash is in form { data: Object, mangle: lambda }
+      # with the :mangle lambda containing any steps to apply the Object
+      # like rewriting /etc/hosts or sending the data elsewhere.
+      # NOTE there may be value in attributing each hash to its
+      # importer, consider that for later as a Hash[Hash].
+      def export
+        @exporters.map(&:export)
+      end
+
+      def export_one_format(format)
+        Zt::Exporters::HostsFileExporter.new.export if format == :hosts
+      end
+    end
+  end
+end

data/lib/zt/exporters/_base_exporter.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Zt
+  module Exporters
+    class BaseExporter
+      attr_accessor :data
+      def initialize
+        super
+      end
+
+      def export
+        abort('export called on non-functional superclass exporter')
+      end
+    end
+  end
+end

data/lib/zt/exporters/hosts_file_exporter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'zt/exporters/_base_exporter'
+require 'zt/conf'
+
+module Zt
+  module Exporters
+    class HostsFileExporter < BaseExporter
+      def export
+        # process the normalised Hash @data and return a String and a Block
+        # defining what to do with the String
+        conf = Zt::Conf.instance.conf
+        output = ''
+        conf.nodes.each_key do |node_id|
+          node = conf.nodes[node_id]
+          node_nets = node[:local][:networks]
+          node_nets.each_key do |net_id|
+            net_zone = conf.networks[net_id][:local][:dns_zone]
+            node_name = node[:remote][:node_name]
+            node_addrs = node[:local][:networks][net_id]
+            node_addrs.each do |node_addr|
+              output += "#{node_addr}\t\t#{node_name}.#{net_zone}\n"
+            end
+          end
+        end
+        "# BEGIN zt\n" + output.lines.sort_by do |a|
+          a.split[1]
+        end.join + "# END zt\n"
+      end
+    end
+  end
+end

data/lib/zt/importers.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'zt/constants'
+require 'zt/importers/_base_importer'
+require 'zt/importers/network_importer'
+require 'zt/importers/node_importer'
+
+module Zt
+  module Importers
+    class Importer
+      attr_accessor :importers
+      def initialize(networks, nodes, *importer_names)
+        importer_names = Zt::Constants::ALL_IMPORTERS if importer_names.empty?
+        importer_classes = importer_names.map do |n|
+          Zt::Importers.const_get(n)
+        end
+        @importers = importer_classes.map { |c| c.new(networks, nodes) }
+      end
+
+      # @return [Array[Hash]] an array of hashes from each exporter.
+      # NOTE there may be value in attributing each hash to its
+      # importer, consider that for later as a Hash[Hash].
+      def import
+        @importers.map(&:import)
+      end
+    end
+  end
+end

data/lib/zt/importers/_base_importer.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'zt/conf'
+
+module Zt
+  module Importers
+    class BaseImporter
+      attr_accessor :networks
+      attr_accessor :nodes
+      def initialize(networks, nodes)
+        @networks = networks
+        @nodes = nodes
+      end
+
+      def import
+        abort('import called on non-functional superclass importer')
+      end
+
+      private
+
+      def dnsify(input)
+        zt_conf = Zt::Conf.instance.conf.zt
+        tld_key = 'top_level_domains'
+        tld = if zt_conf.key?(tld_key) && !zt_conf[tld_key].empty?
+                zt_conf[tld_key]
+              else
+                'zt'
+              end
+        clean = input.tr('-', '_')
+        clean = clean.gsub(/([\W])/, '-')
+        clean = clean.tr('_', '-')
+        clean = clean.gsub(/(-+)/, '-')
+        clean = "network-#{clean}" unless clean.match?(/^[A-Za-z]/)
+        clean = clean.gsub(Regexp.new("-#{tld}$"), '')
+        clean.gsub(/(-+)/, '-')
+      end
+
+      def qualify(zone)
+        zt_conf = Zt::Conf.instance.conf.zt
+        "#{dnsify(zone)}.#{zt_conf['top_level_domain']}"
+      end
+    end
+  end
+end

data/lib/zt/importers/network_importer.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'zt/conf'
+require 'zt/importers/_base_importer'
+
+module Zt
+  module Importers
+    class NetworkImporter < BaseImporter
+      def import
+        output = {}
+        # normalise data
+        normalised_networks = networks.map do |n|
+          {
+            network_id: n['id'],
+            network_name: n['config']['name'],
+            network_description: n['description'],
+            network_total_members: n['totalMemberCount'],
+            network_authorized_members: n['authorizedMemberCount'],
+            network_pending_members:
+              (n['totalMemberCount'] - n['authorizedMemberCount'])
+          }
+        end
+        domains_conf = Zt::Conf.instance.conf.domains
+        normalised_networks.each do |n|
+          zone = if domains_conf.key? n[:network_id]
+                   if n[:network_id].empty?
+                     qualify(n[:network_id])
+                   else
+                     qualify(domains_conf[n[:network_id]])
+                   end
+                 else
+                   qualify(n[:network_name])
+                 end
+          output[n[:network_id]] = {} unless output.key?(n[:network_id])
+          output[n[:network_id]][:remote] = n
+          output[n[:network_id]][:local] = {
+            dns_zone: zone
+          }
+        end
+        {
+          networks: output
+        }
+      end
+    end
+  end
+end

data/lib/zt/importers/node_importer.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'zt/importers/_base_importer'
+
+module Zt
+  module Importers
+    class NodeImporter < BaseImporter
+      def import
+        output = {}
+        hostnames = {}
+        memberships = {}
+        # normalise data
+        nodes.each_key do |network_id|
+          net = nodes[network_id]
+          normalised_nodes = net.map do |node|
+            {
+              node_id: node['nodeId'],
+              node_name: node['name'],
+              node_addr: node['config']['ipAssignments'],
+              node_authed: node['config']['authorized']
+            }
+          end
+          normalised_nodes.each do |n|
+            hostnames[n[:node_id]] = [] unless hostnames.key?(n[:node_id])
+            memberships[n[:node_id]] = [] unless memberships.key?(n[:node_id])
+
+            hostnames[n[:node_id]].append(n[:node_name])
+            memberships[n[:node_id]].append([network_id, n[:node_addr]])
+            n.delete(:node_addr)
+            output[n[:node_id]] = {} unless output.key?(n[:node_id])
+            output[n[:node_id]][:remote] = n
+            output[n[:node_id]][:local] = {}
+          end
+          output.each_key do |k|
+            output[k][:remote][:node_name] = hostnames[k].max_by do |i|
+              hostnames[k].count(i)
+            end
+            memberships[k].each do |m|
+              output[k][:local][:networks] = {} unless
+                output[k][:local].key? :networks
+
+              output[k][:local][:networks][m[0]] = m[1]
+            end
+
+          end
+        end
+        {
+          nodes: output
+        }
+      end
+    end
+  end
+end
+

data/lib/zt/remote_api.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'httparty'
+require 'zt/conf'
+
+module Zt
+  module RemoteAPI
+    class ZeroTierAPI
+      include HTTParty
+
+      base_uri 'https://my.zerotier.com/api'
+
+      def initialize
+        @ztc = Zt::Conf.instance.conf
+        # noinspection RubyStringKeysInHashInspection
+        @req_opts = {
+          headers: {
+            'Authorization' => "Bearer #{@ztc.zt['token']}"
+          }
+        }
+      end
+
+      def networks
+        get_parsed('/network')
+      end
+
+      def network_members(network_id)
+        get_parsed("/network/#{network_id}/member")
+      end
+
+      private
+
+      def get_parsed(path)
+        self.class.get(path, @req_opts).parsed_response
+      end
+
+    end
+  end
+end

data/lib/zt/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Zt
+  VERSION = '0.1.1'
+end

data/zt.gemspec

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'zt/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'zt'
+  spec.version       = Zt::VERSION
+  spec.authors       = ['Dave Williams']
+  spec.email         = ['dave@dave.io']
+
+  spec.summary       = 'ZeroTier administration toolbox'
+  spec.description   =
+    'Utilities and glue to make working with ZeroTier networks ' \
+    'a bit more friendly'
+  spec.homepage      = 'https://github.com/daveio/zt'
+  spec.license       = 'MIT'
+
+
+  if spec.respond_to?(:metadata)
+    # spec.metadata['allowed_push_host'] =
+    #   'http://localhost'
+    spec.metadata['homepage_uri'] = spec.homepage
+    spec.metadata['source_code_uri'] = 'https://github.com/daveio/zt'
+    spec.metadata['changelog_uri'] =
+      'https://raw.githubusercontent.com/daveio/zt/master/CHANGELOG.md'
+  else
+    raise 'RubyGems 2.0 or newer is required to protect ' \
+          'against public gem pushes.'
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been
+  # added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.match(%r{^(test|spec|features)/})
+    end
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'httparty', '~> 0.0', '>= 0.10.0'
+  spec.add_dependency 'thor', '~> 0.0'
+  spec.add_dependency 'xdg', '~> 2.0'
+
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'dotenv', '~> 2.0'
+  spec.add_development_dependency 'pry', '~> 0.0'
+  spec.add_development_dependency 'rake', '~> 12.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop', '~> 0.0', '>= 0.49.0'
+  spec.add_development_dependency 'rubocop-performance', '~> 1.0'
+  spec.add_development_dependency 'ruby-debug-ide', '~> 0.0'
+end