mtik_ppp_active_2_directory 1.0.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mtik_ppp_active_2_directory.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler/gem_tasks'
+

data/bin/mtik_ppp_active_2_directory

@@ -0,0 +1,91 @@
+# coding: utf-8
+require 'optparse'
+require 'syslog'
+require 'mtik_ppp_active_2_directory'
+
+class Args
+  Error = Class.new(StandardError)
+
+  attr_reader :verbose, :retry_timeout
+
+  def initialize
+    @verbose = STDOUT.tty?
+    @retry_timeout = 15 # seconds
+  end
+
+  def self.parse
+    self.new.tap { |args| args.parse }
+  end
+
+  def parse
+    opts = OptionParser.new
+    opts.banner = 'Usage: <host> <username> <password> <dir> [options]'
+
+    opts.separator ''
+    opts.separator 'Options:'
+    opts.on('-v', '--[no-]verbose', 'Print debug messages to stdout',
+            '(default: true if stdout is a TTY)') { |v| @verbose = v }
+    opts.on('--retry-timeout SECONDS', Integer, 'Wait before restarting after an error',
+            "(default: #{@retry_timeout})") { |i| @retry_timeout = i }
+
+    opts.separator ''
+    opts.separator 'IP addresses assigned to the remote end of PPP connections will be'
+    opts.separator 'created in <dir> as a symbolic link pointing to the interface name.'
+    opts.separator ''
+
+    opts.parse!
+    ARGV.size == 4 || raise(Error, "need 4 arguments, but #{ARGV.size} provided")
+
+  rescue Error, OptionParser::ParseError => err
+    STDERR << opts << 'Error: ' << err << "\n"
+    exit(2)
+  end
+
+  def directory
+    ARGV[3]
+  end
+  
+  def mikrotik
+    Hash[[:host, :user, :pass].zip(ARGV[0, 3])]
+  end
+end
+
+class Main
+  def initialize
+    args
+    sync
+  end
+
+  def args
+    @args ||= Args.parse.tap do |args|
+      Syslog.open($PROGRAM_NAME, Syslog::LOG_PID, Syslog::LOG_DAEMON)
+      args.verbose && MtikPppActive2Directory::Log.output(&method(:info))
+    end
+  end
+
+  def sync
+    MtikPppActive2Directory.sync(args.mikrotik, args.directory)
+  rescue => err
+    err("Error: #{err}")
+    err.backtrace.each { |line| err(" #{line}") }
+    sleep(args.retry_timeout)
+    retry
+  end
+
+  # Send +message+ to syslog and STDERR.
+  # @param [String] message
+  # @return [void]
+  def err(message)
+    Syslog.err('%s', message)
+    STDERR << message << "\n" if STDERR.tty?
+  end
+
+  # Send +message+ to STDOUT.
+  # @param [String] message
+  # @return [void]
+  def info(message)
+    STDOUT << message << "\n"
+  end
+end
+
+Main.new

data/lib/mtik_ppp_active_2_directory.rb

@@ -0,0 +1,66 @@
+require 'mtik_ppp_active_2_directory/version'
+require 'mtik_ppp_active_2_directory/log'
+require 'mtik_ppp_active_2_directory/directory'
+require 'mtik_ppp_active_2_directory/mikrotik'
+
+module MtikPppActive2Directory
+  # Synchronize Mikrotik's PPP active connections with a directory containing symbolic links.
+  #
+  # @param [Hash] src The object passed to the +mtik+ gem (keys: +host+, +user+, +pass+)
+  # @param [String] dst The directory holding the symbolic links
+  def self.sync(src, dst)
+    Log.info { "Synchronizing router at [#{src[:host]}] with directory [#{dst}]" }
+    Sync.new(src, dst).sync
+  end
+
+  class Sync
+    def initialize(src, dst)
+      @mtik = Mikrotik.new(src)
+      @dir = Directory.new(path:dst)
+    end
+
+    def sync
+      @mtik.watch { |*args| send(*args) }
+    end
+
+    # @param [Hash] mm Mikrotik Map {IP => user}
+    def start(mm)
+      dm = Hash[@dir.list.to_a] # Directory Map {IP => user}
+      mm.each_pair do |m_ip, m_user|
+        if dm.key? m_ip
+          if m_user != dm[m_ip]
+            update(m_ip, m_user)
+          end
+        else
+          add(m_ip, m_user)
+        end
+      end
+      dm.each_pair do |d_ip, d_user|
+        unless mm.key? d_ip
+          delete(d_ip, d_user)
+        end
+      end
+    end
+
+    # @param [String] ip
+    # @param [String] user
+    def add(ip, user)
+      Log.info { "Adding IP [#{ip}] user [#{user}]" }
+      @dir[ip] = user
+    end
+
+    # @param [String] ip
+    # @param [String] user
+    def update(ip, user)
+      Log.info { "Updating IP [#{ip}] user [#{user}]" }
+      @dir[ip] = user
+    end
+
+    # @param [String] ip
+    # @param [String] user
+    def delete(ip, user)
+      Log.info { "Deleting IP [#{ip}] user [#{user}]" }
+      @dir.delete(ip)
+    end
+  end
+end

data/lib/mtik_ppp_active_2_directory/directory.rb

@@ -0,0 +1,76 @@
+# coding: utf-8
+
+module MtikPppActive2Directory
+  class Directory
+    Error = Class.new(StandardError)
+    SyncError = Class.new(Error)
+
+    # The {#list} method will not enumerate symbolic links that do not match this regular expression.
+    # Other methods may raise Error.
+    IP_RE = %r{ \A \d{1,3} \. \d{1,3} \. \d{1,3} \. \d{1,3} \z }x
+
+    # Manage a directory of symbolic links.
+    #
+    # The IP address is the name of the symbolic link.
+    # The user name is what the symbolic link points to.
+    #
+    # @param [Hash] params
+    # @option params [String] :path The path to the directory containing symbolic links
+    def initialize(params)
+      @path = params[:path]
+    end
+
+    # Return the user name associated with +ip+.
+    #
+    # @param [String] ip
+    #
+    # @raise [SyncError] When the +ip+ is not found
+    # @return [String] The interface associated with +ip+
+    def [](ip)
+      (ip =~ IP_RE) || raise(Error, "Invalid IP [#{ip}]")
+      file = File.join(@path, ip)
+      File.readlink(file)
+    rescue Errno::ENOENT
+      raise(SyncError, "IP [#{ip}] not found [#{file}]")
+    rescue Errno::EINVAL
+      raise(Error, "IP [#{ip}] is not a symlink [#{file}]")
+    end
+
+    # Associate +user+ to +ip+.
+    #
+    # @param [String] ip
+    # @param [String] user
+    def []=(ip, user)
+      (ip =~ IP_RE) || raise(Error, "Invalid IP [#{ip}]")
+      file = File.join(@path, ip)
+      tmp = "#{file}.tmp"
+      File.symlink(user, tmp)
+      File.rename(tmp, file)
+    end
+
+    # Delete the +ip+ association.
+    #
+    # @param [String] ip
+    #
+    # @raise [SyncError] When the +ip+ is not found
+    # @return [void]
+    def delete(ip)
+      (ip =~ IP_RE) || raise(Error, "Invalid IP [#{ip}]")
+      file = File.join(@path, ip)
+      File.unlink(file)
+    rescue Errno::ENOENT
+      raise(SyncError, "IP [#{ip}] not found [#{file}]")
+    end
+
+    # Enumerate all IP associations.
+    #
+    # @return [Enumerator] Arrays with: IP, user
+    def list
+      Enumerator.new do |y|
+        Dir.foreach(@path) do |de| file = File.basename(de)
+        (file =~ IP_RE) && (value = self[file]) && (y << [file, value])
+        end
+      end
+    end
+  end
+end

data/lib/mtik_ppp_active_2_directory/log.rb

@@ -0,0 +1,18 @@
+# coding: utf-8
+
+module MtikPppActive2Directory
+  module Log
+    module_function
+
+    # Call #output to replace this method.
+    def info
+    end
+
+    # Set the logging method.
+    def output(&block)
+      define_singleton_method(:info) do |&message|
+        block.call(message.call)
+      end
+    end
+  end
+end

data/lib/mtik_ppp_active_2_directory/mikrotik.rb

@@ -0,0 +1,121 @@
+# coding: utf-8
+require 'mtik'
+
+module MtikPppActive2Directory
+  class Mikrotik
+    Error = Class.new(StandardError)
+    RouterError = Class.new(Error)
+    SyncError = Class.new(Error)
+
+    def initialize(params)
+      @mtik_params = params.select { |k,_| %w(host user pass).include? k.to_s }
+      @mtik_params.update(cmd_timeout:86400)
+    end
+
+    # Enumerate the PPP active connections.
+    #
+    # @return [Enumerator] Arrays with: IP, user
+    def list
+      Enumerator.new do |y|
+        @cache.each_value do |re|
+          y << [re['address'], re['name']]
+        end
+      end
+    end
+
+    # Watch for modifications to the PPP active connections.
+    #
+    # @yield [method, *data]
+    #
+    # The first +method+ yielded is :start.
+    # +data+ is a Hash of {IP => user}.
+    #
+    # Afterwards, two +method+s may be yielded: :add and :delete.
+    # +data+ is the IP and user, added or deleted.
+    def watch(&block)
+      @cache = {}
+
+      # Listen for modifications to the PPP active connections.
+      # Since they haven't been fully fetched yet, buffer them for later.
+      buffer = []
+      request('/ppp/active/listen', '=.proplist=.dead,.id,name,address') do |re|
+        buffer ? buffer.push(re) : update(re, &block) # [1]
+      end
+
+      # Fetch all PPP active connections.
+      connection.wait_for_request(
+          request('/ppp/active/print', '=.proplist=.id,name,address') do |re|
+            @cache[re['.id']] = re
+          end
+      )
+
+      # Apply modifications that happened during the 'print'.
+      # Updates that happened after 'listen' started, but before 'print' completed,
+      # may cause #update to raise SyncError. It's probably okay to ignore that.
+      buffer.each do |bre|
+        update(bre, &block) rescue SyncError
+      end
+      # With 'print' done, call 'update' directly instead of buffering.
+      buffer = nil # See [1]
+
+      # Start by yielding the entire PPP active connections list.
+      # Afterwards, only changes will be yielded.
+      yield(:start, Hash[list.to_a])
+
+      # Give control to the 'mtik' gem.
+      connection.wait_all
+      raise(Error, "The 'watch' method should never return")
+    end
+
+    private
+
+    # @param [Hash] re
+    # @return [Hash] The same +re+
+    def add(re)
+      if @cache.key?(re['.id'])
+        raise(SyncError, "ID #{re['.id']} already in cache")
+      else
+        @cache[re['.id']] = re
+      end
+    end
+
+    # @param [Hash] re
+    # @return [Hash] The deleted +re+
+    def delete(re)
+      @cache.delete(re['.id']).tap do |deleted_re|
+        unless deleted_re
+          raise(SyncError, "ID #{re['.id']} not in cache")
+        end
+      end
+    end
+
+    # @param [Hash] re
+    def update(re)
+      method = re.key?('.dead') ? :delete : :add
+      re = send(method, re)
+      yield(method, re['address'], re['name'])
+    end
+
+    # @return [MTik::Connection]
+    def connection
+      @connection ||= MTik::Connection.new(@mtik_params).tap do
+        Log.info { "Connecting to Mikrotik at #{@mtik_params.inspect}" }
+      end
+    end
+
+    # @return [MTik::Request]
+    def request(*args)
+      Log.info { "Mikrotik request: #{args.inspect}" }
+      connection.request_each(*args) do |request|
+        while (re = request.reply.shift)
+          Log.info { "Mikrotik reply: #{re.inspect}" }
+          if re.key?('!re') ; yield(re)
+          elsif re.key?('!done') ; nil
+          elsif re.key?('!trap') ; raise(RouterError, re['message'])
+          else raise(Error, "Unrecognized Mikrotik reply: #{re.inspect}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mtik_ppp_active_2_directory/version.rb

@@ -0,0 +1,3 @@
+module MtikPppActive2Directory
+  VERSION = '1.0.0'
+end

data/mtik_ppp_active_2_directory.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mtik_ppp_active_2_directory/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'mtik_ppp_active_2_directory'
+  spec.version       = MtikPppActive2Directory::VERSION
+  spec.authors       = ['André Luiz dos Santos']
+  spec.email         = ['andre.netvision.com.br@gmail.com']
+  spec.summary       = %q{Synchronize Mikrotik's PPP active users with a directory.}
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+
+  spec.add_runtime_dependency 'mtik', '~> 4.0'
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: mtik_ppp_active_2_directory
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- André Luiz dos Santos
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: mtik
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: 
+email:
+- andre.netvision.com.br@gmail.com
+executables:
+- mtik_ppp_active_2_directory
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Rakefile
+- bin/mtik_ppp_active_2_directory
+- lib/mtik_ppp_active_2_directory.rb
+- lib/mtik_ppp_active_2_directory/directory.rb
+- lib/mtik_ppp_active_2_directory/log.rb
+- lib/mtik_ppp_active_2_directory/mikrotik.rb
+- lib/mtik_ppp_active_2_directory/version.rb
+- mtik_ppp_active_2_directory.gemspec
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Synchronize Mikrotik's PPP active users with a directory.
+test_files: []