presence 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/.simplecov

@@ -0,0 +1,14 @@
+class SimpleCov::Formatter::QualityFormatter
+  def format(result)
+    SimpleCov::Formatter::HTMLFormatter.new.format(result)
+    File.open('coverage/covered_percent', 'w') do |f|
+      f.puts result.source_files.covered_percent.to_f
+    end
+  end
+end
+SimpleCov.formatter = SimpleCov::Formatter::QualityFormatter
+
+SimpleCov.start do
+  add_filter '/spec/'
+  add_group 'CLI', 'lib/duple/cli'
+end

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Jason Wadsworth
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Presence
+
+Monitors the local network for presence of network clients by MAC address.
+
+## Installation
+
+Install arping (Mac OS X)
+
+    $ brew install arping
+
+Install arping (Debian/Ubuntu)
+
+    $ sudo apt-get install arping
+
+Install the gem
+
+    $ gem install presence
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,22 @@
+#!/usr/bin/env rake
+
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+begin
+  require 'cane/rake_task'
+
+  desc "Run cane to check quality metrics"
+  Cane::RakeTask.new(:cane) do |cane|
+    cane.abc_max = 15
+    cane.style_measure = 100
+    cane.style_glob = '{lib}/**/*.rb'
+    cane.gte = {'coverage/covered_percent' => 50}
+  end
+rescue LoadError
+  warn "cane not available, quality task not provided."
+end
+
+task :default => [:spec, :cane]

data/bin/presence_scan

@@ -0,0 +1,21 @@
+#! /usr/bin/env ruby
+
+require 'rubygems'
+
+if File.exists?(File.join(File.expand_path('../..', __FILE__), '.git'))
+  lib_path = File.expand_path('../../lib', __FILE__)
+  $:.unshift(lib_path)
+end
+
+require 'presence'
+# Presence::CLI::Root.start
+
+# s = Presence::Scanner.new
+# s.register_listener(Presence::Logger.new)
+# s.register_listener(Presence::Tracker.new)
+# s.scan
+
+Presence::Scanner.scan_loop do |s|
+  s.register_listener(Presence::Logger.new)
+  s.register_listener(Presence::Tracker.new)
+end

data/lib/presence/commands.rb

@@ -0,0 +1,18 @@
+module Presence
+  # Wrapper class for shell command execution.
+  class Commands
+    def arping(ip)
+      result = run("sudo arping -c 1 #{ip}")
+      [cmd, result]
+    end
+
+    def local_ip
+      result = run('ifconfig | grep broadcast')
+      result.scan(/[\d\.]+/).first
+    end
+
+    def run(command)
+      `#{command}`
+    end
+  end
+end

data/lib/presence/errors.rb

@@ -0,0 +1,7 @@
+module Presence
+  # Raised when the presence command is executed in an unsupported environment.
+  class InvalidEnvironment < StandardError; end
+
+  # Raised when an invalid listener is registered with the Presence::Scanner.
+  class InvalidListener < StandardError; end
+end

data/lib/presence/listeners/logger.rb

@@ -0,0 +1,65 @@
+require 'logger'
+
+module Presence
+  # Scanner listener that sends descriptions of scan events to a log. By
+  # default, it uses a Logger instance that writes to stdout. To enable more
+  # verbose output, set:
+  #
+  #   logger.level = ::Logger::INFO
+  #
+  # or:
+  #
+  #   logger.level = ::Logger::DEBUG
+  #
+  # To write to a file or some other outlet, pass an instance of Logger to the
+  # constructor.
+  class Logger
+    attr_accessor :logger
+
+    def initialize(log = nil)
+      if log.nil?
+        log = ::Logger.new(STDOUT)
+        log.level = ::Logger::WARN
+        log.formatter = proc do |severity, datetime, progname, msg|
+          "#{msg}\n"
+        end
+      end
+      self.logger = log
+    end
+
+    def listener_registered(listener, scanner)
+      logger.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}"
+    end
+
+    def scan_finished(ip_prefix, range)
+      logger.info "Scan finished."
+    end
+
+    def ip_scanned(ip, cmd, result)
+      logger.debug " - Checked #{ip} with #{cmd}"
+      result.split("\n").each do |l|
+        logger.debug "    #{l}"
+      end
+    end
+
+    def localhost_found(ip, mac)
+      logger.debug " * Found localhost!"
+    end
+
+    def mac_found(ip, mac)
+      logger.debug
+      logger.debug " * Found #{mac} at #{ip}"
+      logger.debug
+    end
+
+    def mac_not_found(ip)
+      logger.debug
+      logger.debug " * No MAC found at #{ip}"
+      logger.debug
+    end
+  end
+end

data/lib/presence/listeners/mac_list.rb

@@ -0,0 +1,15 @@
+module Presence
+  # Scanner listener that stores a hash of MAC address to IP address for all
+  # MACs found by the scanner.
+  class MACList
+    attr_accessor :macs_found
+
+    def initialize
+      @macs_found = {}
+    end
+
+    def mac_found(ip, mac)
+      @macs_found[mac] = ip
+    end
+  end
+end

data/lib/presence/listeners/mac_printer.rb

@@ -0,0 +1,9 @@
+module Presence
+
+  # Scanner listener that prints all MACs found by the scanner to stdout.
+  class MACPrinter
+    def mac_found(ip, mac)
+      puts "#{ip} : #{mac}"
+    end
+  end
+end

data/lib/presence/listeners/nmapper.rb

@@ -0,0 +1,23 @@
+module Presence
+
+  # Scanner listener that executes and prints the output from nmap for all MACs
+  # found by the scanner.
+  class NMapper
+    def localhost_found(ip, mac)
+      @local_ip = ip
+      @local_mac = mac
+    end
+
+    def mac_found(ip, mac)
+      return if ip == @local_ip
+
+      result = `sudo nmap -O #{ip}`
+      puts '*' * 50
+      puts "* IP: #{ip}"
+      result.split("\n").each do |l|
+        puts "    #{l}"
+      end
+      puts '*' * 50
+    end
+  end
+end

data/lib/presence/listeners/tracker.rb

@@ -0,0 +1,53 @@
+require 'presence/listeners/mac_list'
+
+module Presence
+
+  # Scanner listener that tracks all MACs found by the scanner. This listener is
+  # intended to be used when scanning in a loop. The tracker will maintain a
+  # 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
+    end
+
+    def mac_found(ip, mac)
+      if @mac_history[mac].nil?
+        mac_connected(mac, ip)
+      elsif @mac_history[mac] != ip
+        mac_changed(mac, @mac_history[mac], ip)
+      end
+      @mac_history[mac] = ip
+    end
+
+    def scan_finished(ip_prefix, range)
+      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)
+        @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.
+    end
+  end
+end

data/lib/presence/scanner.rb

@@ -0,0 +1,108 @@
+require 'presence/errors'
+
+module Presence
+
+  # Scans a network for connected clients, captures the MAC address, and
+  # dispatches related events to any registered listeners.
+  class Scanner
+    PAIR = '[0-9a-f]{2}'
+    SEP = '\:'
+    MAC_REGEXP = Regexp.new("(#{6.times.map {PAIR}.join(SEP)})")
+
+    attr_accessor :listeners, :options
+
+    def initialize(options = nil)
+      options ||= {}
+      self.options = {
+        ip_prefix:    nil,
+        octet_range: (1..255)
+      }.merge(options)
+      self.listeners = []
+      @commands = Presence::Commands.new
+    end
+
+    def register_listener(l)
+      raise Presence::InvalidListener.new("Listener cannot be nil") if l.nil?
+      listeners << l
+      dispatch(:listener_registered, l, self)
+    end
+
+    def localhost_ip
+      unless @localhost_ip
+        @localhost_ip = @commands.local_ip
+      end
+      @localhost_ip
+    end
+
+    def ip_prefix
+      unless options[:ip_prefix]
+        options[:ip_prefix] = localhost_ip.split('.')[0,3].join('.')
+      end
+      options[:ip_prefix]
+    end
+
+    def octet_range
+      options[:octet_range]
+    end
+
+    def scan
+      dispatch(:scan_started, ip_prefix, octet_range)
+      octet_range.each do |i|
+        scan_ip("#{ip_prefix}.#{i}")
+      end
+      dispatch(:scan_finished, ip_prefix, octet_range)
+    end
+
+    def scan_ip(ip)
+      cmd, result = @commands.arping(ip)
+      dispatch(:ip_scanned, ip, cmd, result)
+      process_scan_result(ip, cmd, result)
+    end
+
+    def process_scan_result(ip, cmd, result)
+      if result =~ MAC_REGEXP
+        mac = $1
+        dispatch(:localhost_found, ip, mac) if ip == localhost_ip
+        dispatch(:mac_found, ip, mac)
+      else
+        dispatch(:mac_not_found, ip)
+      end
+    end
+
+    def dispatch(event, *args)
+      listeners.each do |l|
+        l.send(event, *args) if l.respond_to?(event)
+      end
+    end
+
+    def to_s
+      "<#{self.class} ip_prefix: '#{self.ip_prefix}' octet_range: (#{self.octet_range})>"
+    end
+
+    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")
+        end
+      end
+
+      def scan_loop(&block)
+        scanner = self.new
+        yield(scanner) if block_given?
+
+        while(true)
+          begin
+            scanner.scan
+          rescue Interrupt
+            break
+          end
+        end
+      end
+    end
+  end
+end

data/lib/presence/version.rb

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

data/lib/presence.rb

@@ -0,0 +1,9 @@
+require 'presence/version'
+require 'presence/errors'
+require 'presence/commands'
+require 'presence/scanner'
+require 'presence/listeners/logger'
+require 'presence/listeners/mac_list'
+require 'presence/listeners/mac_printer'
+require 'presence/listeners/nmapper'
+require 'presence/listeners/tracker'

data/presence.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'presence/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "presence"
+  gem.version       = Presence::VERSION
+  gem.authors       = ["Jason Wadsworth"]
+  gem.email         = ["jdwadsworth@gmail.com"]
+  gem.description   = %q{Monitors the local network for presence of network clients by MAC address.}
+  gem.summary       = %q{Plays theme music when d8:d1:cb:b3:af:c4 arrives.}
+  gem.homepage      = "https://github.com/subakva/presence"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  # gem.add_dependency('thor')
+
+  gem.add_development_dependency('rake', ['~> 0.9.2'])
+  gem.add_development_dependency('rspec', ['~> 2.11.0'])
+  gem.add_development_dependency('cane', ['~> 2.3.0'])
+  gem.add_development_dependency('simplecov', ['~> 0.7.1'])
+end

data/spec/presence/scanner_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe Presence::Scanner do
+  let(:local_ip)  { '10.0.1.30' }
+  let(:local_mac) { '8d:1d:bc:3b:fa:4c' }
+
+  let(:ip)          { '10.0.1.31' }
+  let(:mac)         { 'd8:d1:cb:b3:af:c4' }
+  let(:arping_cmd)  { "sudo arping -c 1 #{ip}" }
+
+  let(:commands) {
+    commands = stub(Presence::Commands)
+    Presence::Commands.should_receive(:new).and_return(commands)
+    commands
+  }
+  let(:listener) {
+    listener = mock(Object)
+    scanner.register_listener(listener)
+    listener
+  }
+  let(:octet_range) { (30..32) }
+  let(:scanner) { Presence::Scanner.new(octet_range: octet_range) }
+
+  before {
+    commands.stub(:local_ip).and_return(local_ip)
+    commands.stub(:arping).and_return([arping_cmd, 'No such jeaun'])
+    commands.stub(:arping).with(local_ip).and_return([arping_cmd, local_mac])
+    commands.stub(:arping).with(ip).and_return([arping_cmd, mac])
+  }
+
+  describe '#scan' do
+    it 'dispatches a scan_started event' do
+      listener.should_receive(:scan_started).with('10.0.1', octet_range)
+      scanner.scan
+    end
+
+    it 'dispatches a scan_finished event' do
+      listener.should_receive(:scan_finished).with('10.0.1', octet_range)
+      scanner.scan
+    end
+
+    it 'scans all IPs in the range' do
+      listener.should_receive(:ip_scanned).with('10.0.1.30', arping_cmd, local_mac)
+      listener.should_receive(:ip_scanned).with('10.0.1.31', arping_cmd, mac)
+      listener.should_receive(:ip_scanned).with('10.0.1.32', arping_cmd, 'No such jeaun')
+      scanner.scan
+    end
+  end
+
+  describe '#scan_ip' do
+    it 'executes arping to check for a mac address' do
+      commands.should_receive(:arping).with(ip).and_return([arping_cmd, mac])
+      scanner.scan_ip(ip)
+    end
+
+    it 'dispatches an ip_scanned event' do
+      listener.should_receive(:ip_scanned).with(ip, arping_cmd, mac)
+      scanner.scan_ip(ip)
+    end
+
+    it 'dispatches a mac_found event' do
+      listener.should_receive(:mac_found).with(ip, mac)
+      scanner.scan_ip(ip)
+    end
+
+    context 'with a localhost IP' do
+      it 'dispatches a localhost_found event' do
+        listener.should_receive(:localhost_found).with(local_ip, local_mac)
+        scanner.scan_ip(local_ip)
+      end
+    end
+
+    context 'with a non-existent IP' do
+      before {
+        commands.stub(:arping).with(ip).and_return([arping_cmd, 'No such jeaun'])
+      }
+
+      it 'does not dispatch a mac_found event' do
+        listener.should_not_receive(:mac_found)
+        scanner.scan_ip(ip)
+      end
+
+      it 'dispatches an ip_scanned event' do
+        listener.should_receive(:ip_scanned).with(ip, arping_cmd, 'No such jeaun')
+        scanner.scan_ip(ip)
+      end
+
+      it 'dispatches a mac_not_found event' do
+        listener.should_receive(:mac_not_found).with(ip)
+        scanner.scan_ip(ip)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+lib_path = File.expand_path('../../lib', __FILE__)
+$:.unshift(lib_path)
+
+require 'simplecov'
+require 'presence'
+Dir['spec/support/**/*.rb'].each { |f| require File.expand_path(f) }
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: presence
+version: !ruby/object:Gem::Version
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors:
+- Jason Wadsworth
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  prerelease: false
+  type: :development
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  name: rake
+- !ruby/object:Gem::Dependency
+  prerelease: false
+  type: :development
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.11.0
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.11.0
+  name: rspec
+- !ruby/object:Gem::Dependency
+  prerelease: false
+  type: :development
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+  name: cane
+- !ruby/object:Gem::Dependency
+  prerelease: false
+  type: :development
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+  name: simplecov
+description: Monitors the local network for presence of network clients by MAC address.
+email:
+- jdwadsworth@gmail.com
+executables:
+- presence_scan
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .simplecov
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/presence_scan
+- lib/presence.rb
+- lib/presence/commands.rb
+- lib/presence/errors.rb
+- lib/presence/listeners/logger.rb
+- lib/presence/listeners/mac_list.rb
+- lib/presence/listeners/mac_printer.rb
+- lib/presence/listeners/nmapper.rb
+- lib/presence/listeners/tracker.rb
+- lib/presence/scanner.rb
+- lib/presence/version.rb
+- presence.gemspec
+- spec/presence/scanner_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/subakva/presence
+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: Plays theme music when d8:d1:cb:b3:af:c4 arrives.
+test_files:
+- spec/presence/scanner_spec.rb
+- spec/spec_helper.rb