lifx_dash 0.1.0

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "lifx_dash"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/lifx_dash

@@ -0,0 +1,112 @@
+#!/usr/bin/env ruby
+
+require "gli"
+require "lifx_dash"
+
+include GLI::App
+
+LOGGER = Logger.new(STDOUT)
+config_options = LifxDash::Configuration.load
+
+program_desc "Toggle LIFX lights with an Amazon Dash button"
+
+version LifxDash::VERSION
+
+subcommand_option_handling :normal
+arguments :strict
+
+desc "Set (and persist) default options for commands"
+long_desc "Use config to set default values for the command options, these will
+be saved to: ~/.lifx_dash.rc.yml and used as defaults. They can still be
+overridden with any arguments passed on the command line."
+skips_pre
+command :config do |c|
+  c.desc "Show the config file"
+  c.switch [:s, :show]
+
+  c.action do |_global_options, options, _args|
+    LifxDash::Configuration.new.run(show_config: options["show"])
+  end
+end
+
+
+desc "Listen for Dash button presses on the network and show packet information"
+long_desc "Monitor the sepcified network interface for any Dash button ARP
+packets and log the device MAC address to stdout. Wait for the network to quiet
+down, before pressing the button, since other devices may respond with ARP
+packets of their own when you press. Take care to choose the MAC address from
+the ARP packet that occurs only once from a single MAC address."
+command :snoop do |c|
+  c.desc "Network Interface"
+  c.default_value config_options["iface"] || "en0"
+  c.flag [:i, :iface]
+
+  c.action do |_global_options, options, _args|
+    LifxDash::Snoop.new(options["iface"]).run
+  end
+end
+
+desc "Listen for a Dash button press, and the toggle selected lights"
+long_desc "Monitor the sepcified network interface, filtered by a Dash button
+MAC address. If a valid ARP packet is detected, the LIFX lights (identified by
+the selector) will be toggled using the LIFX HTTP API (v1). You can optionally
+pass a LIFX bulb selector (the bulb ID), or choose to daemonize the `monitor`
+process.
+
+You can get a free LIFX API token from here: https://cloud.lifx.com/settings
+
+If running as a daemon (-d switch), this command will log to:
+#{LifxDash::Daemonizer::LOG_FILE} by default. Use the --log-file flag to
+overrride this location."
+command :monitor do |c|
+
+  c.desc "Dash button MAC address"
+  c.default_value config_options["mac-address"]
+  c.flag [:m, :"mac-address"]
+
+  c.desc "LIFX HTTP API Token"
+  c.default_value config_options["token"]
+  c.flag [:t, :token]
+
+  c.desc "LIFX Bulb Selector"
+  c.default_value config_options["selector"] || "all"
+  c.flag [:s, :selector]
+
+  c.desc "Network Interface"
+  c.default_value config_options["iface"] || "en0"
+  c.flag [:i, :iface]
+
+  c.desc "Log file location (when running as a daemon)"
+  c.default_value config_options["log-file"] || LifxDash::Daemonizer::LOG_FILE
+  c.flag [:l, :"log-file"]
+
+  c.desc "Dameonize the monitor process"
+  c.switch [:d, :daemonize]
+
+  c.action do |_global_options, options, _args|
+    help_now!("a valid Dash button MAC address option (-m) is required: use `lifx_dash snoop #{options["iface"]}` to find it") unless options["mac-address"]
+    help_now!("a valid LIFX API Token option (-t) is required: get one from https://cloud.lifx.com/settings") unless options["token"]
+
+    if options["daemonize"]
+      LifxDash::Daemonizer.start(options["log-file"])
+    end
+
+    LifxDash::Monitor.new(
+      iface: options["iface"],
+      token: options["token"],
+      mac: options["mac-address"],
+      selector: options["selector"]
+    ).run
+  end
+end
+
+pre do |_global_options, _command, options, _args|
+  # check user has root access for packet sniffing
+  if Process.euid.zero?
+    true
+  else
+    help_now!("sudo required: you must be a root user to capture packets on #{options["iface"]}")
+  end
+end
+
+exit run(ARGV)

data/bin/setup

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+# install deps
+bundle install
+
+# generate man page and rdocs
+bundle exec ronn man/lifx_dash.1.ronn
+bundle exec rake rdoc

data/features/lifx_dash.feature

@@ -0,0 +1,17 @@
+Feature: Show help information
+  In order to show command line help
+
+  Scenario: Show general command line help
+    When I get help for "lifx_dash"
+    Then the output should contain "    lifx_dash - Toggle LIFX lights with an Amazon Dash button"
+    Then the output should match /   config  - (.*)/
+    Then the output should match /   help    - (.*)/
+    Then the output should match /   monitor - (.*)/
+    Then the output should match /   snoop   - (.*)/
+    And the exit status should be 0
+
+  Scenario: Show config help
+    When I run `lifx_dash help config`
+    Then the output should contain "    config - Set (and persist) default options for commands"
+    Then the output should contain "   -s, --[no-]show - Show the config file"
+    And the exit status should be 0

data/features/step_definitions/lifx_dash_steps.rb

@@ -0,0 +1,4 @@
+When /^I get help for "([^"]*)"$/ do |app_name|
+  @app_name = app_name
+  step %(I run `#{app_name} help`)
+end

data/features/support/env.rb

@@ -0,0 +1 @@
+require 'aruba/cucumber'

data/lib/lifx_dash.rb

@@ -0,0 +1,13 @@
+# stdlib
+require "logger"
+
+# gem
+require "lifx_dash/version"
+require "lifx_dash/capturer"
+require "lifx_dash/daemonizer"
+require "lifx_dash/lifx_http_api"
+
+# commands
+require "lifx_dash/configuration"
+require "lifx_dash/monitor"
+require "lifx_dash/snoop"

data/lib/lifx_dash/capturer.rb

@@ -0,0 +1,37 @@
+require "packetfu"
+
+module LifxDash
+  class Capturer
+
+    attr_reader :iface
+
+    def initialize(network_iface_id)
+      @iface = network_iface_id
+    end
+
+    def listen(&block)
+      # examine packets on the stream
+      capturer.stream.each do |packet|
+        pkt = PacketFu::ARPPacket.parse(packet)
+        # parse packet header
+        mac = PacketFu::EthHeader.str2mac(pkt.eth_src)
+        # valid ARP pkt when opcode is 1
+        if pkt.arp_opcode == 1
+          block.call(pkt, mac) if block
+        end
+      end
+    end
+
+
+    private
+
+    def capturer
+      # filter and capture ARP packets on network interface
+      @capturer ||= PacketFu::Capture.new(
+        iface: @iface,
+        start: true,
+        filter: "arp"
+      )
+    end
+  end
+end

data/lib/lifx_dash/configuration.rb

@@ -0,0 +1,68 @@
+require "yaml"
+
+module LifxDash
+  class Configuration
+
+    CONFIG_FILE    = File.join(ENV["HOME"], ".lifx_dash.rc.yml")
+    OPTION_PROMPTS = {
+      "iface"       => "Network interface identifier e.g. en0 (choose from ifconfig -l)",
+      "token"       => "LIFX API token (get a free personal token at cloud.lifx.com)",
+      "mac-address" => "Dash button MAC address (use lifx_dash snoop to find it)",
+      "selector"    => "LIFX bulb selector e.g. all or a LIFX bulb ID",
+      "log-file"    => "Log file location (when running as a daemon)"
+    }
+
+    def self.load
+      if File.exist?(CONFIG_FILE)
+        YAML.load_file(CONFIG_FILE)
+      else
+        {}
+      end
+    end
+
+    def run(show_config: false)
+      # decide to show config or start configuring
+      show_config ? show : configure
+    end
+
+    def show
+      if File.exist?(CONFIG_FILE)
+        puts "Configuration file at #{CONFIG_FILE} ...\n\n"
+        puts File.read(CONFIG_FILE)
+        puts "\nChange these options with `lifx_dash config`"
+      else
+        puts "No configuration file exists at #{CONFIG_FILE}"
+      end
+    end
+
+    def configure
+      puts "Configuring lifx_dash ...\n\n"
+      user_options = ask_for_options
+
+      if user_options.values.all?(&:nil?)
+        puts "\nNo options set, configuration is unchanged"
+      else
+        File.open(CONFIG_FILE, "w") do |file|
+          YAML::dump(user_options, file)
+        end
+        puts "\nConfiguration saved to #{CONFIG_FILE}"
+      end
+    end
+
+    def ask_for_options
+      OPTION_PROMPTS.keys.reduce({}) do |acc, key|
+        print " * #{OPTION_PROMPTS[key]}: "
+        acc.merge(key => parse_user_input(STDIN.gets.strip))
+      end
+    end
+
+    def parse_user_input(str)
+      # handle empty strings
+      if str.empty?
+        nil
+      else
+        str
+      end
+    end
+  end
+end

data/lib/lifx_dash/daemonizer.rb

@@ -0,0 +1,39 @@
+module LifxDash
+  class Daemonizer
+
+    LOG_FILE = "/tmp/lifx_dash.log"
+
+    def self.start(log_file = LOG_FILE)
+      # fork process (skip IO redirect to /dev/null)
+      Process.daemon(false, true)
+      # show pid and log file info on stdout right away
+      puts "[#{Process.pid}] Starting lifx_dash ... (daemon logging to #{log_file})"
+      redirect_io(log_file)
+    end
+
+    # Free the STDIN/STDOUT/STDERR file descriptors and point them somewhere
+    # sensible - inspired by daemons gem
+    def self.redirect_io(log_file)
+      STDIN.reopen '/dev/null'
+
+      begin
+        # ensure log file exists with good permissions
+        FileUtils.mkdir_p(File.dirname(log_file), :mode => 0755)
+        FileUtils.touch log_file
+        File.chmod(0644, log_file)
+
+        # reopen STOUT stream to file
+        STDOUT.reopen log_file, 'a'
+        STDOUT.sync = true
+      rescue ::StandardError
+        STDOUT.reopen '/dev/null'
+      end
+
+      # reopen STERR stream to STDOUT (file stream)
+      STDERR.reopen STDOUT
+      STDERR.sync = true
+    rescue => e
+      raise "#{self} - error: could not redirect IO - #{e.message}"
+    end
+  end
+end

data/lib/lifx_dash/lifx_http_api.rb

@@ -0,0 +1,72 @@
+require "net/https"
+require "json"
+
+module LifxDash
+  class LifxHTTPApi
+
+    BASE_URI = "api.lifx.com/v1"
+
+    attr_reader :token, :logger
+
+    ##
+    # Initialize a new api client with a an API auth token and logger
+    # If no logger is passed, the default LOGGER constant will be used e.g.
+    #
+    #   LifxDash::LifxHTTPApi.new("my-token-here", Logger.new(STDOUT))
+    #
+    def initialize(api_token, logger = LOGGER)
+      @token = api_token
+      @logger = logger
+    end
+
+    ##
+    # Call the toggle-power endpoint on the LIFX HTTP API.
+    # Pass a `selector` argument (defaults to 'all'). The API auth token is
+    # passed via HTTP Basic AUTH.
+    #
+    # The method logs success, warning or errors to the logger. Success is
+    # determined by a 2XX response code and a valid JSON response body like so:
+    #
+    #   {"results":[{"id":"d073d500ec8e","label":"Golden Boy","status":"ok"}]}
+    #
+    def toggle(selector = "all")
+      uri = URI("https://#{BASE_URI}/lights/#{selector}/toggle")
+      logger.info "Toggling lights! (via #{BASE_URI})"
+
+      Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+        req = Net::HTTP::Post.new(uri)
+        req.add_field "Authorization", "Bearer #{token}"
+        res = http.request(req)
+        if res.code.to_s =~ /^2/ && success?(res.body)
+          logger.info "Lights toggled successfully!"
+          logger.info "API reply (#{res.code}): #{res.body}"
+        else
+          logger.warn "Warning: Possible issue with LIFX lights or HTTP API response"
+          logger.warn "API reply (#{res.code}): #{res.body}"
+        end
+      end
+    rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError, URI::InvalidURIError,
+             Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
+      logger.error "Error: POST request to #{BASE_URI} failed: #{e.message}"
+      raise e
+    end
+
+
+    private
+
+    def success?(response_body)
+      results = parse_results(response_body)
+      if results
+        results.all? { |r| r["status"] == "ok" }
+      end
+    end
+
+    def parse_results(response_body)
+      if response_body && !response_body.strip.empty?
+        JSON.parse(response_body)["results"]
+      end
+    rescue JSON::ParserError
+      nil
+    end
+  end
+end

data/lib/lifx_dash/monitor.rb

@@ -0,0 +1,31 @@
+module LifxDash
+  class Monitor
+
+    attr_reader :token, :mac, :selector, :iface
+
+    def initialize(token: nil, mac: nil, selector: "all", iface: "en0")
+      @iface    = iface
+      @token    = token
+      @mac      = mac
+      @selector = selector
+    end
+
+    def run
+      puts "Starting lifx_dash monitor ..."
+      puts " * listening on #{iface} for Dash button #{mac} presses to toggle #{selector} bulb(s)"
+
+      LifxDash::Capturer.new(iface).listen do |pkt, source_mac_addr|
+        if source_mac_addr == mac
+          LOGGER.info "Detected Dash button press from MAC address: #{mac} -- pkt summary: #{pkt.peek}"
+          lifx_api.toggle(selector)
+        end
+      end
+    end
+
+    private
+
+    def lifx_api
+      @lifx_api ||= LifxDash::LifxHTTPApi.new(token)
+    end
+  end
+end

data/lib/lifx_dash/snoop.rb

@@ -0,0 +1,20 @@
+module LifxDash
+  class Snoop
+
+    attr_reader :iface
+
+    def initialize(network_iface_id)
+      @iface = network_iface_id
+    end
+
+    def run
+      puts "Snooping for dash button packets on #{iface} ... press [CTRL-c] to stop\n\n"
+      puts " * wait for the network to quiet down, before pressing the button"
+      puts " * you might get more than 1 ARP packet when pressing, use the MAC address that occurs once\n\n"
+
+      LifxDash::Capturer.new(iface).listen do |pkt, mac|
+        LOGGER.info "possible Dash button press from MAC address: #{mac} -- pkt summary: #{pkt.peek}"
+      end
+    end
+  end
+end