peak 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2b395c9e001b9be92ec7523d17b639f45551d64b
-  data.tar.gz: bbb594e7ea2200d8a9452be19ef03115b21aecee
+  metadata.gz: df65f4faa4d3b4e36b51a9d6b4a5bba37bb2c992
+  data.tar.gz: 9b35a626888fe27afe140abe5dc0bef82d154ae7
 SHA512:
-  metadata.gz: 5d45e7971b96c7996477fd314f19bb6763e9e0e2dfbebabf211f3d7aeb6dc548163771a09c50ec13b2f67db851dd4e17ed0d69749861e44743e5e98ac4ddd0ec
-  data.tar.gz: f61760fa1c991287e410e042dbb3dca2d1f1397468c6599b86df77f50cc9a04ed6befd70d6493a10e9cdb1336d57d7ca263857b995e87dfd3e5e44c8748489fa
+  metadata.gz: 712d1e69d00909111a9bca843918276148103c3372b69f1b08ec61176195edbd31f936c12eef7f7960b5f73a3730094f1937431215fc4f0ae38a34ecbb9c2b4d
+  data.tar.gz: 8f3a5a14d1a7d28b2e16d1d6bde9df2d2a11b5a01d988d7ed0dcdf445fd56fd143a7d22aeb83cc34c615d2c28de7e9aac5f4c77a73359f6e1ae679b82181c7a0

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 1.0.2
+
+* Added proper cleanup before exiting when a sigterm or sigint is received. This allows serial connections to be
+  shutdown and KISS mode on the TNC to be exited.
+* Added a Domain-specific Language for the routing and mangling of frames.
+* By default frames are now preemptively digipeated.
+
 ## 1.0.1
 
 * Added beacon plugin to transmit beacon every 10 minutes.

data/CONTRIBUTORS.md

@@ -0,0 +1,13 @@
+* Jeffrey Phillips Freeman (WI2ARD) - http://JeffreyFreeman.me
+* Martin Murray (KD8LVZ)
+* Paul McMillan - https://github.com/PaulMcMillan
+* Russ Innes
+* John Hogenmiller (KB3DFZ) - https://github.com/ytjohn
+* Phil Gagnon N1HHG
+* Ben Benesh - https://github.com/bbene
+* Joe Goforth
+* Rick Eason
+* Jay Nugent
+* Pete Loveall (AE5PL)
+* darksidelemm - https://github.com/darksidelemm
+* agmuino - https://github.com/agmuino

data/README.rdoc

@@ -1,9 +1,10 @@
 = Peak
 
 {<img src="https://badge.fury.io/rb/peak.svg" alt="Gem Version" />}[https://badge.fury.io/rb/peak]
+{<img src="http://img.shields.io/badge/yard-docs-blue.svg" />}[http://www.rubydoc.info/github/Syncleus/peak/master]
 
 Author::  Jeffrey Phillips Freeman, WI2ARD (freemo@gmail.com)
-Copyright:: Copyright (c) 2016 Syncleus, Inc.
+Copyright:: Copyright (c) 2016 - present Syncleus, Inc.
 
 Peak is a full suite APRS client and reference implementation for the APEX protocol. APEX is a next generation APRS
 based protocol. This repository represents the official application implementing APEX. It is a full-feature application
@@ -34,12 +35,12 @@ This is Free software: Apache License v2
 
 == Development
 
-After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive
+After checking out the repo, run +bin/setup+ to install dependencies. You can also run +bin/console+ for an interactive
 prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the
-version number in `app_info.rb`, and then run `bundle exec rake release`, which will create a git tag for the version,
-push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run <code>bundle exec rake install</code>. To release a new version, update the
+version number in +app_info.rb+, and then run <code>bundle exec rake release</code>, which will create a git tag for the version,
+push git commits and tags, and push the +.gem+ file to {rubygems.org}[https://rubygems.org].
 
 == Links
 

data/bin/peak

@@ -14,7 +14,7 @@ class App
         Peak::main
     end
 
-    description 'Peak: a reference implementation for the APEX protocol.'
+    description 'Peak is a reference implementation for the APEX protocol which is itself based on the APRS protocol.'
     version Peak::VERSION
 
     # Proxy to an OptionParser instance's on method

data/lib/peak.rb

@@ -1,12 +1,25 @@
 require 'peak/echo'
 require 'peak/config_loader'
 require 'peak/plugin_loader'
+require 'peak/routing/route'
 
 module Peak
 
     def self.main
         config = find_config(true)
+        unless config
+            echo_colorized_error('Could not find a valid configuration file in any of the default locations')
+            return
+        end
+
         port_map = init_port_map(config)
+        unless port_map
+            echo_colorized_error('Configuration could not be loaded,  format was invalid.')
+            return
+        end
+
+        Signal.trap('INT') { throw :sig }
+        Signal.trap('TERM') { throw :sig }
         
         active_plugins = {}
         plugins = load_plugins
@@ -19,20 +32,45 @@ module Peak
         end
 
         # Handle any packets we read in.
-        while true
-            something_read = false
-            port_map.values.each do |tnc_port|
-                frame = tnc_port.read
-                if frame
-                    something_read = true
-                    active_plugins.each_key do |plugin|
-                        plugin.handle_packet(frame, tnc_port)
+        catch (:sig) do
+            while true
+                something_read = false
+                port_map.values.each do |tnc_port|
+                    frame = tnc_port.read
+                    if frame
+                        something_read = true
+                        routed_frame = Routing::Route.handle_frame(frame, config, true, tnc_port.name)
+                        if routed_frame
+                            if routed_frame[:output_target]
+                                port_map[routed_frame[:output_target]].write(routed_frame[:frame])
+                            else
+                                active_plugins.each_key do |plugin|
+                                    plugin.handle_packet(routed_frame[:frame], tnc_port)
+                                end
+                            end
+                        end
                     end
                 end
-            end
-            unless something_read
-                sleep(1)
+                unless something_read
+                    sleep(1)
+                end
             end
         end
+
+        puts
+        puts 'Shutdown signal caught, shutting down...'
+
+        # Let's cleanup some stuff before exiting.
+        active_plugins.keys.each do |plugin|
+            plugin.stop
+        end
+        active_plugins.values.each do |plugin_thread|
+            plugin_thread.join
+        end
+        port_map.values.each do |port|
+            port.close
+        end
+        
+        puts 'Peak successfully shutdown.'
     end
 end

data/lib/peak/app_info.rb

@@ -1,3 +1,3 @@
 module Peak
-    VERSION = "1.0.1"
+    VERSION = "1.0.2"
 end

data/lib/peak/config_loader.rb

@@ -41,7 +41,7 @@ module Peak
                 tnc_name = section_name.strip.split(' ')[1].strip
                 if tnc_name == 'IGATE'
                     echo_colorized_error('IGATE was used as the name for a TNC in the configuration, this name is reserved')
-                    return false
+                    return nil
                 end
             
                 kiss_tnc = nil
@@ -50,7 +50,7 @@ module Peak
                     baud = section_content['baud']
                     kiss_tnc = Apex::AprsKiss.new(Kiss::KissSerial.new(com_port, baud))
                 else
-                    return false
+                    return nil
                 end
                 
                 if section_content.key?('kiss_init')
@@ -63,14 +63,14 @@ module Peak
                         kiss_tnc.connect
                     else
                         echo_colorized_error('Invalid configuration, value assigned to kiss_init was not recognized: ' + kiss_init_string)
-                        return false
+                        return nil
                     end
                 else
                     kiss_tnc.connect
                 end
     
                 unless config_lookup_enforce(section_content, 'port_count')
-                    return false
+                    return nil
                 end
                 
                 port_count = section_content['port_count']
@@ -80,22 +80,22 @@ module Peak
                     port_section_name = 'PORT ' + port_name
                     
                     unless config_lookup_enforce(config, port_section_name)
-                        return false
+                        return nil
                     end
                     port_section = config[port_section_name]
                     
                     unless config_lookup_enforce(port_section, 'identifier')
-                        return false
+                        return nil
                     end
                     port_identifier = port_section['identifier']
 
                     unless config_lookup_enforce(port_section, 'net')
-                        return false
+                        return nil
                     end
                     port_net = port_section['net']
 
                     unless config_lookup_enforce(port_section, 'tnc_port')
-                        return false
+                        return nil
                     end
                     tnc_port = port_section['tnc_port']
                     

data/lib/peak/routing/route.rb

@@ -0,0 +1,687 @@
+module Peak
+    module Routing
+        class Rules
+            protected
+            def initialize(frame, config, frame_port, next_target=nil)
+                @frame = frame
+                @next_target = next_target
+                @config = config
+                @frame_port = frame_port
+
+                @port_info = {}
+                config.each do |section_name, section_content|
+                    if section_name.start_with?('TNC ')
+                        tnc_name = section_name.strip.split(' ')[1].strip
+                        if tnc_name != 'IGATE'
+                            port_count = section_content['port_count']
+            
+                            (1..port_count).each do |port|
+                                port_name = tnc_name + '-' + port.to_s
+                                port_section_name = 'PORT ' + port_name
+                                port_section = config[port_section_name]
+                                port_identifier = port_section['identifier']
+                                port_net = port_section['net']
+                                tnc_port = port_section['tnc_port']
+
+                                old_paradigm = port_section['old_paradigm']
+                                unless old_paradigm
+                                    old_paradigm = []
+                                end
+
+                                new_paradigm_all = port_section['new_paradigm']
+                                new_paradigm = []
+                                if new_paradigm_all and new_paradigm_all.length > 0
+                                    new_paradigm_all.each do |new_paradigm_one|
+                                        new_paradigm << {:target => new_paradigm_one['target'], :max_hops => new_paradigm_one['max_hops']}
+                                    end
+                                end
+
+                                preemptive = port_section['preemptive']
+                
+                                @port_info[port_name] = {
+                                    :port_identifier => port_identifier,
+                                    :port_net => port_net,
+                                    :tnc_port => tnc_port,
+                                    :old_paradigm => old_paradigm,
+                                    :new_paradigm => new_paradigm,
+                                    :preemptive => preemptive
+                                }
+                            end
+                        end
+                    end
+                end
+            end
+
+            private
+            def self.args_parser(*args)
+                if !args or !args.length or args.length <= 0
+                    condition = args[0]
+                    true_target = :pass
+                    false_target = :pass
+                elsif !!args[0] == args[0] # if the first argument is a boolean
+                    condition = args[0]
+                    true_target = args.length >= 2 ? args[1] : :pass
+                    false_target = args.length >= 3 ? args[2] : :pass
+                else
+                    condition = true
+                    true_target = args.length >= 1 ? args[0] : :pass
+                    false_target = args.length >= 2 ? args[1] : :pass
+                end
+
+                next_target = condition ? true_target : false_target
+
+                {
+                    :condition => condition,
+                    :true_target => true_target,
+                    :false_target => false_target,
+                    :next_target => next_target
+                }
+            end
+
+            private
+            def do_next_target(next_target)
+                if next_target != :pass
+                    @next_target = next_target
+                    throw :new_target
+                end
+                return
+            end
+
+            private
+            def select_next_hop(hops)
+                select_future_hops(hops)[0]
+            end
+
+            private
+            def select_future_hops(hops)
+                hops.select { |hop| !hop.end_with? '*'  }
+            end
+
+            private
+            def select_net_band_hops(hops)
+                hops.select { |hop| hop =~ /\d{1,4}M$/i  }
+            end
+
+            private
+            def select_net_freq_hops(hops)
+                hops.select { |hop| hop =~ /\d{1,4}M\d{1,3}$/i  }
+            end
+
+            private
+            def select_net_hops(hops)
+                hops.select { |hop| hop =~ /\d{1,4}M\d{0,3}$/i  }
+            end
+
+            private
+            def net_freg_to_band_hops(hops)
+                select_net_hops(hops).map { |hop| hop.gsub(/M\d{0,3}$/i, 'M')  }
+            end
+
+            private
+            def all_my_names
+                names = @port_info.values.map { |info| info[:port_identifier].upcase }
+                names += net_freg_to_band_hops(@port_info.values.map {|info| info[:port_net].upcase })
+                names += select_net_freq_hops(@port_info.values.map {|info| info[:port_net].upcase })
+                names.uniq
+            end
+
+            private
+            def self.array_upcase(things)
+                things.map {|s|
+                    if !s.is_a? Regexp
+                        s.upcase
+                    else
+                        s
+                    end
+                }
+            end
+
+            private
+            def self.is_hop_old_paradigm?(hop, old_paradigm)
+                if old_paradigm.length <= 0
+                    return false
+                end
+
+                old_paradigm = Rules.array_upcase(old_paradigm)
+                hop = hop.upcase
+
+                old_paradigm.each do |target|
+                    if target.is_a? Regexp
+                        if hop =~ target
+                            return true
+                        end
+                    elsif hop == target
+                        return true
+                    end
+                end
+
+                false
+            end
+
+            private
+            def self.is_hop_new_paradigm?(hop, new_paradigm_all)
+                if new_paradigm_all.length <= 0
+                    return false
+                end
+
+                hop = hop.upcase
+                unless hop =~ /[A-Z]*-\d{1,2}/
+                    return false
+                end
+                hop_split = hop.split('-')
+                if !hop_split or hop_split.length != 2
+                    return false
+                end
+                hop_target = hop_split[0]
+                hop_hops = hop_split[1].to_i
+                if hop_hops <= 0
+                    return false
+                end
+
+                new_paradigm_all.each do |new_paradigm|
+                    if new_paradigm[:target].is_a? Regexp
+                        if hop_target =~ new_paradigm[:target]
+                            return true
+                        end
+                    elsif hop_target == new_paradigm[:target].upcase
+                        return true
+                    end
+                end
+
+                false
+            end
+
+            private
+            def self.is_hop_identifier_me(hop, identifiers)
+                if identifiers.include? hop.upcase
+                    true
+                else
+                    false
+                end
+            end
+
+            protected
+            def filter(*args)
+                args = Rules.args_parser(*args)
+                do_next_target(args[:next_target])
+            end
+
+            protected
+            def consume_next_hop(*args)
+                args = Rules.args_parser(*args)
+
+                if has_next_hop? and args[:condition]
+                    catch(:done) do
+                        @frame[:path].each do |hop|
+                            unless hop.end_with? '*'
+                                hop << '*'
+                                throw :done
+                            end
+                        end
+                    end
+                end
+                
+                do_next_target(args[:next_target])
+            end
+
+            private
+            def self.consume_new_paradigm(hop)
+                hop_split = hop.split('-')
+                target = hop_split[0]
+                hop_count = hop_split[1].to_i
+                hop_count -= 1
+                if hop_count > 0
+                    hop.replace( target + '-' + hop_count.to_s )
+                else
+                    hop.replace(target + '*')
+                end
+            end
+
+            protected
+            def route(*args, preemptive: nil)
+                args = Rules.args_parser(*args)
+
+                if has_next_hop? and args[:condition]
+                    detected = false
+
+                    port_name = @frame_port
+                    port_info = @port_info[port_name]
+
+                    if preemptive == nil
+                        preemptive = port_info[:preemptive]
+                        if preemptive == nil
+                            preemptive = true
+                        end
+                    end
+
+                    old_paradigm = nil
+                    if port_info.key? :old_paradigm and port_info[:old_paradigm].length > 0
+                        old_paradigm = Rules.array_upcase(port_info[:old_paradigm])
+                    end
+
+
+                    new_paradigm = nil
+                    if port_info.key? :new_paradigm and port_info[:new_paradigm].length > 0
+                        new_paradigm = port_info[:new_paradigm]
+                    end
+
+
+                    next_hop = select_next_hop(@frame[:path])
+                    if all_my_names.include? next_hop.upcase or Rules.is_hop_old_paradigm?(next_hop, old_paradigm)
+                        next_hop << '*'
+                    elsif Rules.is_hop_new_paradigm?(next_hop, new_paradigm)
+                        Rules.consume_new_paradigm(next_hop)
+                    end
+
+                    if preemptive
+                        future_hops = select_future_hops(@frame[:path])
+                        identifiers = @port_info.values.map { |info| info[:port_identifier].upcase }
+                        future_hops.reverse.each do |hop|
+                            if detected
+                                hop << '*'
+                            elsif identifiers.include? hop.upcase
+                                hop << '*'
+                                detected = true
+                            end
+                        end
+                    end
+                end
+
+                do_next_target(args[:next_target])
+            end
+            
+            protected
+            def seen?
+                identifiers = @port_info.values.map { |info| info[:port_identifier].upcase }
+                if identifiers.include? @frame[:source].upcase
+                    return true
+                end
+                
+                @frame[:path].each do |hop|
+                    unless hop.end_with? '*'
+                        return false
+                    end
+                    
+                    if identifiers.include? hop.upcase.chomp('*')
+                        return true
+                    end
+                end
+                
+                false
+            end
+
+            protected
+            def destination_me?
+                identifiers = @port_info.values.map { |info| info[:port_identifier].upcase }
+                if identifiers.include? @frame[:destination].upcase
+                    true
+                else
+                    false
+                end
+            end
+
+            protected
+            def has_next_hop?
+                @frame[:path].each do |hop|
+                    unless hop.end_with? '*'
+                        return true
+                    end
+                end
+                return false
+            end
+
+            protected
+            def next_hop_identifier_me?
+                unless has_next_hop?
+                    return false
+                end
+
+                identifiers = @port_info.values.map { |info| info[:port_identifier].upcase }
+                Rules.is_hop_identifier_me(select_next_hop(@frame[:path]), identifiers)
+            end
+
+            protected
+            def future_hop_identifier_me?
+                unless has_next_hop?
+                    return false
+                end
+
+                identifiers = @port_info.values.map { |info| info[:port_identifier].upcase }
+                if (identifiers & select_future_hops(Rules.array_upcase(@frame[:path]))).empty?
+                    false
+                else
+                    true
+                end
+            end
+
+            protected
+            def next_hop_net_band_me?
+                unless has_next_hop?
+                    return false
+                end
+
+                net_bands = net_freg_to_band_hops(@port_info.values.map {|info| info[:port_net].upcase })
+                next_bands = select_net_band_hops([select_next_hop(@frame[:path]).upcase])
+
+                if next_bands.length <= 0 or net_bands.length <= 0
+                    return false
+                end
+
+                next_band = next_bands[0]
+
+                if net_bands.include? next_band
+                    false
+                else
+                    true
+                end
+            end
+
+            protected
+            def future_hop_net_band_me?
+                unless has_next_hop?
+                    return false
+                end
+
+                net_bands = net_freg_to_band_hops(@port_info.values.map {|info| info[:port_net].upcase })
+                next_bands = Rules.array_upcase(select_net_band_hops(@frame[:path]))
+
+                if next_bands.length <= 0 or net_bands.length <= 0
+                    return false
+                end
+
+                if (net_bands & next_bands).empty?
+                    true
+                else
+                    false
+                end
+            end
+
+            protected
+            def next_hop_net_freq_me?
+                unless has_next_hop?
+                    return false
+                end
+
+                net_freqs = select_net_freq_hops(@port_info.values.map {|info| info[:port_net].upcase })
+                next_freqs= select_net_freq_hops([select_next_hop(@frame[:path]).upcase])
+
+                if next_freqs.length <= 0 or net_freqs.length <= 0
+                    return false
+                end
+
+                next_band = next_bands[0]
+
+                if net_bands.include? next_band
+                    false
+                else
+                    true
+                end
+            end
+
+            protected
+            def future_hop_net_freq_me?
+                unless has_next_hop?
+                    return false
+                end
+
+                net_freqs = select_net_freq_hops(@port_info.values.map {|info| info[:port_net].upcase })
+                next_freqs = select_net_freq_hops(select_future_hops(Rules.array_upcase(@frame[:path])))
+
+                if next_freqs.length <= 0 or net_freqs.length <= 0
+                    return false
+                end
+
+                if (net_freqs & next_freqs).empty?
+                    true
+                else
+                    false
+                end
+            end
+
+            protected
+            def next_hop_old_paradigm?
+                unless has_next_hop?
+                    return false
+                end
+
+                port_name = @frame_port
+                port_info = @port_info[port_name]
+
+                if !port_info.key? :old_paradigm or port_info[:old_paradigm].length <= 0
+                    return false
+                end
+
+                old_paradigm = Rules.array_upcase(port_info[:old_paradigm])
+                next_hop = select_next_hop(@frame[:path]).upcase
+
+                Rules.is_hop_old_paradigm?(next_hop, old_paradigm)
+            end
+
+            protected
+            def future_hop_old_paradigm?
+                unless has_next_hop?
+                    return false
+                end
+
+                port_name = @frame_port
+                port_info = @port_info[port_name]
+
+                if !port_info.key? :old_paradigm or port_info[:old_paradigm].length <= 0
+                    return false
+                end
+
+                old_paradigm = Rules.array_upcase(port_info[:old_paradigm])
+                future_hops = select_future_hops(@frame[:path]).map { |s| s.upcase }
+
+                old_paradigm.each do |target|
+                    if target.is_a? Regexp
+                        future_hops.each do |hop|
+                            if hop =~ target
+                                return true
+                            end
+                        end
+                    elsif future_hops.include? target
+                        return true
+                    end
+                end
+
+                false
+            end
+
+            protected
+            def next_hop_new_paradigm?
+                unless has_next_hop?
+                    return false
+                end
+
+                port_name = @frame_port
+                port_info = @port_info[port_name]
+
+                if !port_info.key? :new_paradigm or port_info[:new_paradigm].length <= 0
+                    return false
+                end
+
+                new_paradigm_all = port_info[:new_paradigm]
+                next_hop = select_next_hop(@frame[:path]).upcase
+
+                Rules.is_hop_new_paradigm?(next_hop, new_paradigm_all)
+            end
+
+            protected
+            def future_hop_new_paradigm?
+                unless has_next_hop?
+                    return false
+                end
+
+                port_name = @frame_port
+                port_info = @port_info[port_name]
+
+                if !port_info.key? :new_paradigm or port_info[:new_paradigm].length <= 0
+                    return false
+                end
+
+                new_paradigm_all = port_info[:new_paradigm]
+                future_hops = select_future_hops(@frame[:path]).map { |s| s.upcase }
+                
+
+                new_paradigm_all.each do |new_paradigm|
+                    if new_paradigm[:target].is_a? Regexp
+                        future_hops.each do |hop|
+                            if hop.include? '-'
+                                hop_split = hop.split('-')
+                                if hop_split and hop_split.length == 2
+                                    hop_target = hop_split[0]
+                                    hop_hops = hop_split[1].to_i
+                                    if hop_hops > 0 and hop_target =~ new_paradigm[:target]
+                                        return true
+                                    end
+                                end
+                            end
+                        end
+                    elsif future_hops.include? new_paradigm[:target].upcase
+                        return true
+                    end
+                end
+
+                false
+            end
+
+            protected
+            def next_hop_net_me?
+                if next_hop_net_band_me? or next_hop_net_freq_me?
+                    true
+                else
+                    false
+                end
+            end
+
+            protected
+            def future_hop_net_me?
+                if future_hop_net_band_me? or future_hop_net_freq_me?
+                    true
+                else
+                    false
+                end
+            end
+
+            protected
+            def next_hop_paradigm?
+                if next_hop_new_paradigm? or next_hop_old_paradigm?
+                    true
+                else
+                    false
+                end
+            end
+
+            protected
+            def future_hop_paradigm?
+                if future_hop_new_paradigm? or future_hop_old_paradigm?
+                    true
+                else
+                    false
+                end
+            end
+
+            protected
+            def next_hop_me?
+                if next_hop_net_me? or next_hop_identifier_me? or next_hop_paradigm?
+                    true
+                else
+                    false
+                end
+            end
+
+            protected
+            def future_hop_me?
+                if future_hop_net_me? or future_hop_identifier_me? or future_hop_paradigm?
+                    true
+                else
+                    false
+                end
+            end
+
+            protected
+            def mine?
+                if future_hop_me? or destination_me?
+                    true
+                else
+                    false
+                end
+            end
+
+            public
+            attr_reader :next_target, :frame
+        end
+
+        class Route
+            @@chains = {}
+
+            public
+            def self.inbound_chain(&block)
+                @@chains[:inbound] = {:target => :input, :block => block}
+            end
+
+            public
+            def self.outbound_chain(&block)
+                @@chains[:outbound] = {:target => :output, :block => block}
+            end
+
+            public
+            def self.side_chain(name, target, &block)
+                @@chains[name] = {:target => target, :block => block}
+            end
+
+            public
+            def self.reset
+                @@chains.clear
+            end
+        end
+
+        # ==== This is the part the user will implement ======
+
+        Route.inbound_chain {
+            filter destination_me?, :pass, :forward
+            filter :input # if this werent here packet would be dropped
+        }
+
+        Route.outbound_chain {
+            filter :output # if this werent here packet would be dropped
+        }
+
+        Route.side_chain(:forward, :output) {
+            filter seen?, :drop
+            filter future_hop_me?, :pass, :drop
+            route :output
+        }
+
+        # ==== Exiting custom code ========
+
+        class Route
+            public
+            def self.handle_frame(frame, config, is_inbound, name)
+                initial_chain = is_inbound ? :inbound : :outbound
+                unless @@chains.key? initial_chain
+                    return nil
+                end
+                
+                rules = Rules.new(frame, config, name, initial_chain)
+                more = true
+                while more and rules.next_target != :input and rules.next_target != :output and rules.next_target != :drop
+                    catch(:new_target) do
+                        rules.instance_eval &@@chains[rules.next_target][:block]
+                        more = false
+                    end
+                end
+
+                if rules.next_target == :drop or !more
+                    return nil
+                end
+
+                {
+                    :output_target => rules.next_target == :output ? name : nil,
+                    :frame => rules.frame
+                }
+            end
+        end
+    end
+end

data/peak.conf.example

@@ -20,12 +20,19 @@ PORT KENWOOD-1:
   identifier: WI2ARD-1
   net: 2M1
   tnc_port: 0
-  beacon_path: [WIDE1-1, WIDE2-2]
-  status_path: [WIDE1-1, WIDE2-2]
+  beacon_path: ['WIDE1-1', 'WIDE2-2']
+  status_path: ['WIDE1-1', 'WIDE2-2']
   beacon_text: '!/:=i@;N.G& --PHG5790/G/D R-I-R H24 C30'
   status_text: '>Listening on 146.52Mhz http://JeffreyFreeman.me'
   id_text: 'WI2ARD/30M1 GATE/2M1 WI2ARD-1/2M1 WIDEN-n IGATE'
-  id_path: [WIDE1-1, WIDE2-2]
+  id_path: ['WIDE1-1', 'WIDE2-2']
+  preemptive: true
+  old_paradigm: ['ECHO', 'PA']
+  new_paradigm:
+  - target: !ruby/regexp '/^WIDE[1-2]{1}$/i'
+    max_hops: 2
+  - target: !ruby/regexp '/^PA[1-5]{1}$/i'
+    max_hops: 5
 
 PORT RPR-1:
   identifier: WI2ARD
@@ -37,6 +44,13 @@ PORT RPR-1:
   status_text: '>Robust Packet Radio http://JeffreyFreeman.me'
   id_text: 'WI2ARD/30M1 GATE/2M1 WI2ARD-1/2M1 WIDEN-n IGATE'
   id_path: [WIDE1-1]
+  preemptive: true
+  old_paradigm: ['ECHO', 'PA']
+  new_paradigm:
+  - target: !ruby/regexp '/^WIDE[1-2]{1}$/i'
+    max_hops: 2
+  - target: !ruby/regexp '/^PA[1-5]{1}$/i'
+    max_hops: 5
 
 IGATE:
   callsign: WI2ARD

data/peak.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
     spec.email = ['jeffrey.freeman@syncleus.com']
 
     spec.summary = %q{Reference implementation for the APEX Radio protocol, an extension to APRS.}
-    spec.description = %q{Reference implementation for the APEX Radio protocol, which is iteself an extension to the APRS protocol.}
+    spec.description = %q{Reference implementation for the APEX Radio protocol, which is itself an extension to the APRS protocol.}
     spec.homepage = 'http://apexprotocol.com'
 
     # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: peak
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Jeffrey Phillips Freeman
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-10-05 00:00:00.000000000 Z
+date: 2016-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -108,7 +108,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.14'
-description: Reference implementation for the APEX Radio protocol, which is iteself
+description: Reference implementation for the APEX Radio protocol, which is itself
   an extension to the APRS protocol.
 email:
 - jeffrey.freeman@syncleus.com
@@ -118,6 +118,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - CHANGELOG.md
+- CONTRIBUTORS.md
 - Gemfile
 - LICENSE
 - README.rdoc
@@ -135,6 +136,7 @@ files:
 - lib/peak/plugins/id.rb
 - lib/peak/plugins/plugin_factory.rb
 - lib/peak/plugins/status.rb
+- lib/peak/routing/route.rb
 - lib/peak/tnc_port.rb
 - peak.conf.example
 - peak.gemspec