presence 0.0.1 → 0.0.2

data/.simplecov

@@ -10,5 +10,6 @@ SimpleCov.formatter = SimpleCov::Formatter::QualityFormatter
 
 SimpleCov.start do
   add_filter '/spec/'
-  add_group 'CLI', 'lib/duple/cli'
+  add_group 'CLI', 'lib/presence/cli'
+  add_group 'Listeners', 'lib/presence/listeners'
 end

data/Rakefile

@@ -13,7 +13,7 @@ begin
     cane.abc_max = 15
     cane.style_measure = 100
     cane.style_glob = '{lib}/**/*.rb'
-    cane.gte = {'coverage/covered_percent' => 50}
+    cane.gte = {'coverage/covered_percent' => 80}
   end
 rescue LoadError
   warn "cane not available, quality task not provided."

data/bin/presence_scan

@@ -8,14 +8,28 @@ if File.exists?(File.join(File.expand_path('../..', __FILE__), '.git'))
 end
 
 require 'presence'
+
 # Presence::CLI::Root.start
 
+# Usage: presence [OPTIONS]
+#
+# presence --start 10.0.1.1 --end 10.0.1.30
+# presence --prefix 192.168.0
+# presence --verbose
+# presence --quiet
+# presence --once
+# presence --loop
+# presence --listener Carnegie::Listener
+
+# --once
 # s = Presence::Scanner.new
 # s.register_listener(Presence::Logger.new)
 # s.register_listener(Presence::Tracker.new)
 # s.scan
 
+# --loop
 Presence::Scanner.scan_loop do |s|
+  # s.options[:octet_range] = (30..32)
   s.register_listener(Presence::Logger.new)
   s.register_listener(Presence::Tracker.new)
 end

data/lib/presence/commands.rb

@@ -2,7 +2,8 @@ module Presence
   # Wrapper class for shell command execution.
   class Commands
     def arping(ip)
-      result = run("sudo arping -c 1 #{ip}")
+      cmd = "sudo arping -c 1 #{ip}"
+      result = run(cmd)
       [cmd, result]
     end
 

data/lib/presence/listeners/http_notifier.rb

@@ -0,0 +1,83 @@
+require "net/https"
+require "uri"
+
+module Presence
+
+  # Scanner listener that sends an HTTP notification whenever a new client
+  # connects or when a connected client disconnects. This listener is intended
+  # to be used with Presence::Tracker when scanning in a loop.
+  class HTTPNotifier
+
+    def initialize(options = nil)
+      options ||= {}
+      @options = {
+        use_ssl: false,
+        verify_mode: OpenSSL::SSL::VERIFY_PEER
+      }.merge(options)
+    end
+
+    def listener_registered(l, scanner)
+      @scanner ||= scanner
+    end
+
+    def mac_connected(mac, ip)
+      notify(:mac_connected, { mac: mac, ip: ip })
+    end
+
+    def mac_disconnected(mac, old_ip)
+      notify(:mac_disconnected, { mac: mac, ip: old_ip })
+    end
+
+    protected
+
+    def notify_uri
+      @notify_uri ||= URI.parse(@options[:url])
+    end
+
+    def notify(event, params)
+      request = prepare_request(event, params)
+      do_request(request)
+    end
+
+    def do_request(request)
+      response = nil
+
+      begin
+        http      = prepare_http
+        response  = http.request(request)
+        check_response(response)
+      rescue  SocketError,
+              Timeout::Error,
+              Errno::ECONNREFUSED,
+              Errno::EHOSTDOWN,
+              Errno::EHOSTUNREACH,
+              Errno::ETIMEDOUT => e
+        @scanner.dispatch(:http_notification_failed, e.class.name, e.message)
+      end
+
+      response
+    end
+
+    def prepare_request(event, params)
+      request = Net::HTTP::Post.new(notify_uri.request_uri, @options[:headers])
+      request.set_form_data(params.merge(event: event))
+      if @options[:username]
+        request.basic_auth(@options[:username], @options[:password])
+      end
+      request
+    end
+
+    def prepare_http
+      http = Net::HTTP.new(notify_uri.host, notify_uri.port)
+      http.use_ssl      = @options[:use_ssl]
+      http.verify_mode  = @options[:verify_mode]
+      http
+    end
+
+    def check_response(response)
+      unless (200..206).map(&:to_s).include?(response.code)
+        @scanner.dispatch(:http_notification_failed, response.code, response.body)
+      end
+    end
+  end
+end

data/lib/presence/listeners/logger.rb

@@ -5,61 +5,88 @@ module Presence
   # default, it uses a Logger instance that writes to stdout. To enable more
   # verbose output, set:
   #
-  #   logger.level = ::Logger::INFO
+  #   logger.log.level = ::Logger::INFO
   #
   # or:
   #
-  #   logger.level = ::Logger::DEBUG
+  #   logger.log.level = ::Logger::DEBUG
   #
-  # To write to a file or some other outlet, pass an instance of Logger to the
+  # To write to a file or some other outlet, pass a Ruby Logger instance to the
   # constructor.
   class Logger
-    attr_accessor :logger
+    attr_accessor :log
 
     def initialize(log = nil)
       if log.nil?
-        log = ::Logger.new(STDOUT)
+        log = ::Logger.new($stdout)
         log.level = ::Logger::WARN
         log.formatter = proc do |severity, datetime, progname, msg|
           "#{msg}\n"
         end
       end
-      self.logger = log
+      self.log = log
     end
 
     def listener_registered(listener, scanner)
-      logger.info "Registered listener: <#{listener.class}> for: #{scanner}"
+      log.info "Registered listener: <#{listener.class}> for: #{scanner}"
     end
 
     def scan_started(ip_prefix, range)
-      logger.info "Checking range: #{ip_prefix}.#{range.first} to #{ip_prefix}.#{range.last}"
+      log.info "Scanning range: #{ip_prefix}.#{range.first} to #{ip_prefix}.#{range.last}"
     end
 
     def scan_finished(ip_prefix, range)
-      logger.info "Scan finished."
+      log.info "Scan finished."
     end
 
     def ip_scanned(ip, cmd, result)
-      logger.debug " - Checked #{ip} with #{cmd}"
+      log.debug " - Checked #{ip} with #{cmd}"
       result.split("\n").each do |l|
-        logger.debug "    #{l}"
+        log.debug "    #{l}"
       end
     end
 
     def localhost_found(ip, mac)
-      logger.debug " * Found localhost!"
+      log.debug " * Found localhost!"
     end
 
     def mac_found(ip, mac)
-      logger.debug
-      logger.debug " * Found #{mac} at #{ip}"
-      logger.debug
+      log.debug " * Found #{mac} at #{ip}"
     end
 
     def mac_not_found(ip)
-      logger.debug
-      logger.debug " * No MAC found at #{ip}"
-      logger.debug
+      log.debug " * No MAC found at #{ip}"
+    end
+
+    protected
+
+    def log_unknown_event(method_sym, *arguments)
+      # puts "method_sym = #{method_sym}"
+      # puts "arguments = #{arguments.inspect}"
+      # puts "log = #{log}"
+      # raise 'hell'
+      log.warn("#{method_sym}: #{arguments.inspect}")
+    end
+
+    # Always log events, even if there is no explicit handler. Generate a
+    # method at runtime so we don't have to do method_missing every time.
+    def method_missing(method_sym, *arguments, &block)
+      arg_names = arguments.each_with_index.map { |arg, i| "arg#{i}" }
+      arg_list = arg_names.join(',')
+      instance_eval <<-RUBY
+        def #{method_sym}(#{arg_list})
+          log_unknown_event(:#{method_sym}, #{arg_list})
+        end
+      RUBY
+      # def method_sym(arg1, arg2, ...)
+      #   log_unknown_event(:method_sym, arg1, arg2, ...)
+      # end
+      send(method_sym, *arguments)
+    end
+
+    # Respond to anything.
+    def respond_to_missing?(method_sym, include_private = false)
+      true
     end
   end
 end

data/lib/presence/listeners/tracker.rb

@@ -7,20 +7,23 @@ module Presence
   # list of MAC addresses on the network and detect when a new client connects
   # or when a connected client disconnects.
   class Tracker
+
     def initialize
       @mac_history = {}
       @current_list = Presence::MACList.new
     end
 
     def listener_registered(l, scanner)
-      scanner.register_listener(@current_list) if l == self
+      @scanner ||= scanner
+      @scanner.register_listener(@current_list) if l == self
     end
 
     def mac_found(ip, mac)
       if @mac_history[mac].nil?
-        mac_connected(mac, ip)
+        dispatch(:mac_connected, mac, ip)
       elsif @mac_history[mac] != ip
-        mac_changed(mac, @mac_history[mac], ip)
+        old_ip = @mac_history[mac]
+        dispatch(:mac_changed, mac, old_ip, ip)
       end
       @mac_history[mac] = ip
     end
@@ -29,25 +32,14 @@ module Presence
       macs_left = @mac_history.keys - @current_list.macs_found.keys
       macs_left.each do |mac|
         old_ip = @mac_history[mac]
-        mac_disconnected(mac, old_ip)
+        dispatch(:mac_disconnected, mac, old_ip)
         @mac_history.delete(mac)
       end
       @current_list.macs_found.clear
     end
 
-    def mac_connected(mac, ip)
-      puts " ** #{mac} connected as #{ip}"
-      # Do something interesting.
-    end
-
-    def mac_changed(mac, old_ip, new_ip)
-      puts " ** #{mac} changed ip from: #{old_ip} to #{new_ip}"
-      # Do something interesting.
-    end
-
-    def mac_disconnected(mac, old_ip)
-      puts " ** #{mac} disconnected from #{old_ip}"
-      # Do something interesting.
+    def dispatch(event, *args)
+      @scanner.dispatch(event, *args)
     end
   end
 end

data/lib/presence/scanner.rb

@@ -82,12 +82,11 @@ module Presence
     class << self
       def check_env
         commands = Commands.new
-        if commands.run('which ifconfig').size == 0
-          raise Presence::InvalidEnvironment.new("Unsupported platform: ifconfig not found.")
-        end
-        if commands.run('which arping').size == 0
-          raise Presence::InvalidEnvironment.new("Unsupported platform: arping not found.")
-          raise Presence::InvalidEnvironment.new("Install arping first: brew install arping")
+        required_commands = %w{ifconfig arping}
+        required_commands.each do |cmd|
+          if commands.run("which #{cmd}").size == 0
+            raise Presence::InvalidEnvironment.new("Unsupported platform: #{cmd} not found.")
+          end
         end
       end
 

data/lib/presence/version.rb

@@ -1,3 +1,3 @@
 module Presence
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/presence.rb

@@ -7,3 +7,4 @@ require 'presence/listeners/mac_list'
 require 'presence/listeners/mac_printer'
 require 'presence/listeners/nmapper'
 require 'presence/listeners/tracker'
+require 'presence/listeners/http_notifier'

data/spec/presence/http_notifier_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe Presence::HTTPNotifier do
+  let(:username) { nil }
+  let(:password) { nil }
+  let(:notifier) {
+    Presence::HTTPNotifier.new(
+      url: 'http://example.com/presence_events.json',
+      username: username,
+      password: password
+    )
+  }
+
+  let(:scanner) { stub(Presence::Scanner) }
+  before { notifier.listener_registered(notifier, scanner) }
+
+  let(:http) { stub(Net::HTTP, :use_ssl= => nil, :verify_mode= => nil) }
+  let(:response) { stub(code: '200') }
+  before {
+    http.stub(:request).and_return(response)
+    Net::HTTP.stub(:new).with('example.com', 80).and_return(http)
+  }
+
+  context 'with a username and password' do
+    let(:username) { 'margot' }
+    let(:password) { 'poppie' }
+
+    it 'sends the username and password in the request' do
+      http.should_receive(:request) do |r|
+        r['authorization'].should == 'Basic bWFyZ290OnBvcHBpZQ=='
+        response
+      end
+      notifier.mac_connected('AA:BB:CC:DD:EE:FF', '10.0.1.49')
+    end
+  end
+
+  it 'dispatches an error notification if the request returns an error code' do
+    response.should_receive(:code).at_least(1).times.and_return('400')
+    response.should_receive(:body).and_return('Invalid request')
+    scanner.should_receive(:dispatch).with(:http_notification_failed, '400', 'Invalid request')
+
+    notifier.mac_connected('AA:BB:CC:DD:EE:FF', '10.0.1.49')
+  end
+
+  it 'dispatches an error notification if the request raises a network error' do
+    http.should_receive(:request).and_raise(SocketError.new('bad things occurred'))
+    scanner.should_receive(:dispatch).with(:http_notification_failed, 'SocketError', 'bad things occurred')
+
+    notifier.mac_connected('AA:BB:CC:DD:EE:FF', '10.0.1.49')
+  end
+
+  it 'sends a POST request on mac_connected' do
+    http.should_receive(:request) do |r|
+      r.method.should == 'POST'
+      r.body.should == 'mac=AA%3ABB%3ACC%3ADD%3AEE%3AFF&ip=10.0.1.49&event=mac_connected'
+      response
+    end
+    notifier.mac_connected('AA:BB:CC:DD:EE:FF', '10.0.1.49')
+  end
+
+  it 'sends a POST request on mac_disconnected' do
+    http.should_receive(:request) do |r|
+      r.method.should == 'POST'
+      r.body.should == 'mac=AA%3ABB%3ACC%3ADD%3AEE%3AFF&ip=10.0.1.49&event=mac_disconnected'
+      response
+    end
+    notifier.mac_disconnected('AA:BB:CC:DD:EE:FF', '10.0.1.49')
+  end
+end

data/spec/presence/logger_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe Presence::Logger do
+  let(:level) { ::Logger::INFO }
+  let(:io) { StringIO.new }
+  let(:log) {
+    log = ::Logger.new(io)
+    log.level = level
+    log.formatter = proc do |severity, datetime, progname, msg|
+      "#{msg}\n"
+    end
+    log
+  }
+  let(:logger) { Presence::Logger.new(log) }
+
+  context 'with no ::Logger specified' do
+    let(:log) { nil }
+
+    it 'logs warnings to stdout by default' do
+      result = capture_stdout do |variable|
+        logger.log.warn('Run, baby, run!')
+      end
+      result.should == "Run, baby, run!\n"
+    end
+
+    it 'does not log info by default' do
+      result = capture_stdout do |variable|
+        logger.log.info('Run, baby, run!')
+      end
+      result.should == ''
+    end
+  end
+
+  context 'with DEBUG logging' do
+    let(:level) { ::Logger::DEBUG }
+
+    it 'logs ip_scanned events' do
+      logger.ip_scanned('10.0.1.1', 'sudo arping', 'nada')
+      io.string.should == " - Checked 10.0.1.1 with sudo arping\n    nada\n"
+    end
+
+    it 'logs localhost_found events' do
+      logger.localhost_found('10.0.1.1', 'AA:BB:CC:DD:EE:FF')
+      io.string.should == " * Found localhost!\n"
+    end
+
+    it 'logs mac_found events' do
+      logger.mac_found('10.0.1.1', 'aa:bb:cc:dd:ee:ff')
+      io.string.should == " * Found aa:bb:cc:dd:ee:ff at 10.0.1.1\n"
+    end
+
+    it 'logs mac_not_found events' do
+      logger.mac_not_found('10.0.1.1')
+      io.string.should == " * No MAC found at 10.0.1.1\n"
+    end
+
+    it 'logs unknown events' do
+      logger.respond_to?(:miracle_occurred).should be_true
+      logger.miracle_occurred('256.256.256.256', 'GG:GG:GG:GG:GG:GG', 49)
+      io.string.should == "miracle_occurred: [\"256.256.256.256\", \"GG:GG:GG:GG:GG:GG\", 49]\n"
+    end
+
+  end
+
+  context 'with INFO logging' do
+    let(:level) { ::Logger::INFO }
+
+    it 'logs listener_registered events' do
+      logger.listener_registered(logger, 'Scanner')
+      io.string.should == "Registered listener: <Presence::Logger> for: Scanner\n"
+    end
+
+    it 'logs scan_started events' do
+      logger.scan_started('10.0.1', (1..255))
+      io.string.should == "Scanning range: 10.0.1.1 to 10.0.1.255\n"
+    end
+
+    it 'logs scan_finished events' do
+      logger.scan_finished('10.0.1', (1..255))
+      io.string.should == "Scan finished.\n"
+    end
+
+    it 'does not log ip_scanned events' do
+      logger.ip_scanned('10.0.1.1', 'sudo arping', 'nada')
+      io.string.should == ''
+    end
+
+    it 'does not log localhost_found events' do
+      logger.localhost_found('10.0.1.1', 'aa:bb:cc:dd:ee:ff')
+      io.string.should == ''
+    end
+
+    it 'does not log mac_found events' do
+      logger.mac_found('10.0.1.1', 'aa:bb:cc:dd:ee:ff')
+      io.string.should == ''
+    end
+
+    it 'does not log mac_not_found events' do
+      logger.mac_not_found('10.0.1.1')
+      io.string.should == ''
+    end
+  end
+end

data/spec/presence/scanner_spec.rb

@@ -10,7 +10,7 @@ describe Presence::Scanner do
 
   let(:commands) {
     commands = stub(Presence::Commands)
-    Presence::Commands.should_receive(:new).and_return(commands)
+    Presence::Commands.stub(:new).and_return(commands)
     commands
   }
   let(:listener) {
@@ -28,6 +28,63 @@ describe Presence::Scanner do
     commands.stub(:arping).with(ip).and_return([arping_cmd, mac])
   }
 
+  describe '.check_env' do
+    before {
+      commands.stub(:run).with('which ifconfig').and_return('/sbin/ifconfig')
+      commands.stub(:run).with('which arping').and_return('/usr/local/sbin/arping')
+    }
+
+    it 'checks for ifconfig' do
+      commands.should_receive(:run).with('which ifconfig').and_return('/sbin/ifconfig')
+      Presence::Scanner.check_env
+    end
+
+    it 'raises an exception if ifconfig is not found' do
+      commands.should_receive(:run).with('which ifconfig').and_return('')
+      expect {
+        Presence::Scanner.check_env
+      }.to raise_error(Presence::InvalidEnvironment, "Unsupported platform: ifconfig not found.")
+    end
+
+    it 'checks for arping' do
+      commands.should_receive(:run).with('which arping').and_return('/usr/local/sbin/arping')
+      Presence::Scanner.check_env
+    end
+
+    it 'raises an exception if arping is not found' do
+      commands.should_receive(:run).with('which arping').and_return('')
+      expect {
+        Presence::Scanner.check_env
+      }.to raise_error(Presence::InvalidEnvironment, "Unsupported platform: arping not found.")
+    end
+  end
+
+  describe '.scan_loop' do
+    let(:scanner) { mock(Presence::Scanner) }
+    before { Presence::Scanner.should_receive(:new).and_return(scanner) }
+
+    it 'scans until interrupted' do
+      scanner.should_receive(:scan)
+      scanner.should_receive(:scan)
+      scanner.should_receive(:scan).and_raise(Interrupt.new)
+      Presence::Scanner.scan_loop
+    end
+
+    it 'yields the scanner instance to a block' do
+      scanner.stub(:scan).and_raise(Interrupt.new)
+      scanner.should_receive(:register_listener)
+      Presence::Scanner.scan_loop do |s|
+        s.register_listener(Object.new)
+      end
+    end
+  end
+
+  describe '#to_s' do
+    it 'overrides to_s' do
+      scanner.to_s.should == "<Presence::Scanner ip_prefix: '10.0.1' octet_range: (30..32)>"
+    end
+  end
+
   describe '#scan' do
     it 'dispatches a scan_started event' do
       listener.should_receive(:scan_started).with('10.0.1', octet_range)

data/spec/presence/tracker_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Presence::Tracker do
+end

data/spec/support/io_spec_helpers.rb

@@ -0,0 +1,33 @@
+module Presence
+  module IOSpecHelpers
+    def suppress_output
+      @original_stdout, $stdout = $stdout, StringIO.new
+      @original_stderr, $stderr = $stderr, StringIO.new
+    end
+
+    def reset_output
+      $stdout = @original_stdout
+      $stderr = @original_stderr
+    end
+
+    def capture_stdout
+      original_stdout, $stdout = $stdout, StringIO.new
+      yield
+      $stdout.string
+    ensure
+      $stdout = original_stdout
+    end
+
+    def capture_stderr
+      original_stderr, $stderr = $stderr, StringIO.new
+      yield
+      $stderr.string
+    ensure
+      $stderr = original_stderr
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include Presence::IOSpecHelpers
+end

metadata

@@ -2,14 +2,14 @@
 name: presence
 version: !ruby/object:Gem::Version
   prerelease: 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Jason Wadsworth
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-23 00:00:00.000000000 Z
+date: 2012-11-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   prerelease: false
@@ -94,6 +94,7 @@ files:
 - lib/presence.rb
 - lib/presence/commands.rb
 - lib/presence/errors.rb
+- lib/presence/listeners/http_notifier.rb
 - lib/presence/listeners/logger.rb
 - lib/presence/listeners/mac_list.rb
 - lib/presence/listeners/mac_printer.rb
@@ -102,8 +103,12 @@ files:
 - lib/presence/scanner.rb
 - lib/presence/version.rb
 - presence.gemspec
+- spec/presence/http_notifier_spec.rb
+- spec/presence/logger_spec.rb
 - spec/presence/scanner_spec.rb
+- spec/presence/tracker_spec.rb
 - spec/spec_helper.rb
+- spec/support/io_spec_helpers.rb
 homepage: https://github.com/subakva/presence
 licenses: []
 post_install_message: 
@@ -129,5 +134,9 @@ signing_key:
 specification_version: 3
 summary: Plays theme music when d8:d1:cb:b3:af:c4 arrives.
 test_files:
+- spec/presence/http_notifier_spec.rb
+- spec/presence/logger_spec.rb
 - spec/presence/scanner_spec.rb
+- spec/presence/tracker_spec.rb
 - spec/spec_helper.rb
+- spec/support/io_spec_helpers.rb