mac-wifi 2.0.0 → 2.1.0

data/lib/mac-wifi/base_model.rb

@@ -0,0 +1,221 @@
+require 'tempfile'
+require_relative '../mac-wifi'
+
+module MacWifi
+
+class BaseModel
+
+  class OsCommandError < RuntimeError
+    attr_reader :exitstatus, :command, :text
+
+    def initialize(exitstatus, command, text)
+      @exitstatus = exitstatus
+      @command = command
+      @text = text
+    end
+  end
+
+
+  def initialize(verbose = false)
+    @verbose_mode = verbose
+  end
+
+
+  def run_os_command(command)
+    output = `#{command} 2>&1` # join stderr with stdout
+    if $?.exitstatus != 0
+      raise OsCommandError.new($?.exitstatus, command, output)
+    end
+    if @verbose_mode
+      puts "\n\n#{'-' * 79}\nCommand: #{command}\n\nOutput:\n#{output}#{'-' * 79}\n\n"
+    end
+    output
+  end
+  private :run_os_command
+
+
+  # This method returns whether or not there is a working Internet connection.
+  # Because of a Mac issue which causes a request to hang if the network is turned
+  # off during its lifetime, we give it only 5 seconds per try,
+  # and limit the number of tries to 3.
+  #
+  # This implementation will probably strike you as overly complex. The following
+  # code looks like it is all that should be necessary, but unfortunately
+  # this implementation often hangs when wifi is turned off while curl is active
+  #
+  # def connected_to_internet?
+  #   script = "curl --silent --head http://www.google.com/ > /dev/null ; echo $?"
+  #   result = `#{script}`.chomp
+  #   puts result
+  #   result == '0'
+  # end
+
+  # TODO Investigate using Curl options: --connect-timeout 1 --max-time 2 --retry 0
+  # to greatly simplify this method.
+  def connected_to_internet?
+
+    tempfile = Tempfile.open('mac-wifi-')
+
+    begin
+      start_status_script = -> do
+        script = "curl --silent --head http://www.google.com/ > /dev/null ; echo $? > #{tempfile.path} &"
+        pid = Process.spawn(script)
+        Process.detach(pid)
+        pid
+      end
+
+      process_is_running = ->(pid) do
+        script = %Q{ps -p #{pid} > /dev/null; echo $?}
+        output = `#{script}`.chomp
+        output == "0"
+      end
+
+      get_connected_state_from_curl = -> do
+        tempfile.close
+        File.read(tempfile.path).chomp == '0'
+      end
+
+      # Do one run, iterating during the timeout period to see if the command has completed
+      do_one_run = -> do
+        end_time = Time.now + 3
+        pid = start_status_script.()
+        while Time.now < end_time
+          if process_is_running.(pid)
+            sleep 0.5
+          else
+            return get_connected_state_from_curl.()
+          end
+        end
+        Process.kill('KILL', pid) if process_is_running.(pid)
+        :hung
+      end
+
+      3.times do
+        connected = do_one_run.()
+        return connected if connected != :hung
+      end
+
+      raise "Could not determine Internet status."
+
+    ensure
+      tempfile.unlink
+    end
+
+  end
+
+
+  # Turns wifi off and then on, reconnecting to the originally connecting network.
+  def cycle_network
+    # TODO: Make this network name saving and restoring conditional on it not having a password.
+    # If the disabled code below is enabled, an error will be raised if a password is required,
+    # even though it is stored.
+    # network_name = current_network
+    wifi_off
+    wifi_on
+    # connect(network_name) if network_name
+  end
+
+
+  def connected_to?(network_name)
+    network_name == connected_network_name
+  end
+
+
+  # Connects to the passed network name, optionally with password.
+  # Turns wifi on first, in case it was turned off.
+  # Relies on subclass implementation of os_level_connect().
+  def connect(network_name, password = nil)
+    # Allow symbols and anything responding to to_s for user convenience
+    network_name = network_name.to_s if network_name
+    password     = password.to_s     if password
+
+    if network_name.nil? || network_name.empty?
+      raise "A network name is required but was not provided."
+    end
+    wifi_on
+    os_level_connect(network_name, password)
+
+    # Verify that the network is now connected:
+    actual_network_name = connected_network_name
+    unless actual_network_name == network_name
+      message = %Q{Expected to connect to "#{network_name}" but }
+      if actual_network_name
+        message << %Q{connected to "#{connected_network_name}" instead.}
+      else
+        message << "unable to connect to any network. Did you "
+      end
+      message << (password ? "provide the correct password?" : "need to provide a password?")
+      raise message
+    end
+    nil
+  end
+
+
+  # Removes the specified network(s) from the preferred network list.
+  # @param network_names names of networks to remove; may be empty or contain nonexistent networks
+  # @return names of the networks that were removed (excludes non-preexisting networks)
+  def remove_preferred_networks(*network_names)
+    networks_to_remove = network_names & preferred_networks # exclude any nonexistent networks
+    networks_to_remove.each { |name| remove_preferred_network(name) }
+  end
+
+
+  def preferred_network_password(preferred_network_name)
+    preferred_network_name = preferred_network_name.to_s
+    if preferred_networks.include?(preferred_network_name)
+      os_level_preferred_network_password(preferred_network_name)
+    else
+      raise "Network #{preferred_network_name} not in preferred networks list."
+    end
+  end
+
+
+  # Waits for the Internet connection to be in the desired state.
+  # @param target_status must be in [:conn, :disc, :off, :on]; waits for that state
+  # @param wait_interval_in_secs sleeps this interval between retries; if nil or absent,
+  #        a default will be provided
+  #
+  def till(target_status, wait_interval_in_secs = nil)
+
+    # One might ask, why not just put the 0.5 up there as the default argument.
+    # We could do that, but we'd still need the line below in case nil
+    # was explicitly specified. The default argument of nil above emphasizes that
+    # the absence of an argument and a specification of nil will behave identically.
+    wait_interval_in_secs ||= 0.5
+
+    finished_predicates = {
+        conn: -> { connected_to_internet? },
+        disc: -> { ! connected_to_internet? },
+        on:   -> { wifi_on? },
+        off:  -> { ! wifi_on? }
+    }
+
+    finished_predicate = finished_predicates[target_status]
+
+    if finished_predicate.nil?
+      raise ArgumentError.new(
+          "Option must be one of #{finished_predicates.keys.inspect}. Was: #{target_status.inspect}")
+    end
+
+    loop do
+      return if finished_predicate.()
+      sleep(wait_interval_in_secs)
+    end
+  end
+
+
+  # Tries an OS command until the stop condition is true.
+  # @command the command to run in the OS
+  # @stop_condition a lambda taking the commands stdout as its sole parameter
+  # @return the stdout produced by the command
+  def try_os_command_until(command, stop_condition, max_tries = 100)
+    max_tries.times do
+      stdout = run_os_command(command)
+      if stop_condition.(stdout)
+        return stdout
+      end
+    end
+    nil
+  end
+end
+end

data/lib/mac-wifi/command_line_interface.rb

@@ -0,0 +1,417 @@
+require_relative 'mac_os_model'
+
+module MacWifi
+
+class CommandLineInterface
+
+  attr_reader :model, :interactive_mode, :options
+
+  class Command < Struct.new(:min_string, :max_string, :action); end
+
+
+  class BadCommandError < RuntimeError
+    def initialize(error_message)
+      super
+    end
+  end
+
+
+  # Help text to be used when requested by 'h' command, in case of unrecognized or nonexistent command, etc.
+  HELP_TEXT = "
+Command Line Switches:                    [mac-wifi version #{MacWifi::VERSION}]
+
+-o[i,j,p,y]               - outputs data in inspect, JSON, puts, or YAML format when not in shell mode
+-s                        - run in shell mode
+-v                        - verbose mode (prints OS commands and their outputs)
+
+Commands:
+
+a[vail_nets]              - array of names of the available networks
+ci                        - connected to Internet (not just wifi on)?
+co[nnect] network-name    - turns wifi on, connects to network-name
+cy[cle]                   - turns wifi off, then on, preserving network selection
+d[isconnect]              - disconnects from current network, does not turn off wifi
+h[elp]                    - prints this help
+i[nfo]                    - a hash of wifi-related information
+l[s_avail_nets]           - details about available networks
+n[etwork_name]            - name (SSID) of currently connected network
+on                        - turns wifi on
+of[f]                     - turns wifi off
+pa[ssword] network-name   - password for preferred network-name
+pr[ef_nets]               - preferred (not necessarily available) networks
+q[uit]                    - exits this program (interactive shell mode only) (see also 'x')
+r[m_pref_nets] network-name - removes network-name from the preferred networks list
+                          (can provide multiple names separated by spaces)
+s[hell]                   - opens an interactive pry shell (command line only)
+t[ill]                    - returns when the desired Internet connection state is true. Options:
+                          1) 'on'/:on, 'off'/:off, 'conn'/:conn, or 'disc'/:disc
+                          2) wait interval, in seconds (optional, defaults to 0.5 seconds)
+w[ifion]                  - is the wifi on?
+x[it]                     - exits this program (interactive shell mode only) (see also 'q')
+
+When in interactive shell mode:
+  * use quotes for string parameters such as method names.
+  * for pry commands, use prefix `%`.
+
+"
+
+
+  def initialize(options)
+    @options = options
+    @model = MacOsModel.new(verbose_mode)
+    @interactive_mode = !!(options.interactive_mode)
+    run_shell if @interactive_mode
+  end
+
+
+  # Until command line option parsing is added, the only way to specify
+  # verbose mode is in the environment variable MAC_WIFI_OPTS.
+  def verbose_mode
+    options.verbose
+  end
+
+
+  def print_help
+    puts HELP_TEXT
+  end
+
+
+  # @return true if awesome_print is available (after requiring it), else false after requiring 'pp'.
+  # We'd like to use awesome_print if it is available, but not require it.
+  # So, we try to require it, but if that fails, we fall back to using pp (pretty print),
+  # which is included in Ruby distributions without the need to install a gem.
+  def awesome_print_available?
+    if @awesome_print_available.nil?  # first time here
+      begin
+        require 'awesome_print'
+        @awesome_print_available = true
+      rescue LoadError
+        require 'pp'
+        @awesome_print_available = false
+      end
+    end
+
+    @awesome_print_available
+  end
+
+
+  def fancy_string(object)
+    awesome_print_available? ? object.ai : object.pretty_inspect
+  end
+
+
+  def fancy_puts(object)
+    puts fancy_string(object)
+  end
+  alias_method :fp, :fancy_puts
+
+
+  # Asserts that a command has been passed on the command line.
+  def validate_command_line
+    if ARGV.empty?
+      puts "Syntax is: #{__FILE__} [options] command [command_options]"
+      print_help
+      exit(-1)
+    end
+  end
+
+
+  # Pry will output the content of the method from which it was called.
+  # This small method exists solely to reduce the amount of pry's output
+  # that is not needed here.
+  def run_pry
+    binding.pry
+
+    # the seemingly useless line below is needed to avoid pry's exiting
+    # (see https://github.com/deivid-rodriguez/pry-byebug/issues/45)
+    _a = nil
+  end
+
+
+  # Runs a pry session in the context of this object.
+  # Commands and options specified on the command line can also be specified in the shell.
+  def run_shell
+    begin
+      require 'pry'
+    rescue LoadError
+      puts "The 'pry' gem and/or one of its prerequisites, required for running the shell, was not found." +
+               " Please `gem install pry`."
+      exit(-1)
+    end
+
+    print_help
+
+    # Enable the line below if you have any problems with pry configuration being loaded
+    # that is messing up this runtime use of pry:
+    # Pry.config.should_load_rc = false
+
+    # Strangely, this is the only thing I have found that successfully suppresses the
+    # code context output, which is not useful here. Anyway, this will differentiate
+    # a pry command from a DSL command, which _is_ useful here.
+    Pry.config.command_prefix = '%'
+
+    run_pry
+  end
+
+
+  # For use by the shell; when typing a command and options, it is passed to process_command_line
+  def method_missing(method_name, *options)
+    method_name = method_name.to_s
+    method_exists = !! find_command_action(method_name)
+    if method_exists
+      process_command_line(method_name, options)
+    else
+      puts(%Q{"#{method_name}" is not a valid command or option. If you intend for this to be a string literal, use quotes or %q/Q{}.})
+    end
+  end
+
+
+  # Processes the command (ARGV[0]) and any relevant options (ARGV[1..-1]).
+  #
+  # CAUTION! In interactive mode, any strings entered (e.g. a network name) MUST
+  # be in a form that the Ruby interpreter will recognize as a string,
+  # i.e. single or double quotes, %q, %Q, etc.
+  # Otherwise it will assume it's a method name and pass it to method_missing!
+  def process_command_line(command, options)
+    action = find_command_action(command)
+    if action
+      action.(*options)
+    else
+      print_help
+      raise BadCommandError.new(
+          %Q{Unrecognized command. Command was "#{command}" and options were #{options.inspect}.})
+    end
+  end
+
+
+  def quit
+    if interactive_mode
+      exit(0)
+    else
+      puts "This command can only be run in shell mode."
+    end
+  end
+
+
+  def cmd_a
+    info = model.available_network_names
+    if interactive_mode
+      info
+    else
+      if post_processor
+        puts post_processor.(info)
+      else
+        message = if model.wifi_on?
+                    "Available networks are:\n\n#{fancy_string(info)}"
+                  else
+                    "Wifi is off, cannot see available networks."
+                  end
+        puts(message)
+      end
+    end
+  end
+
+
+  def cmd_ci
+    connected = model.connected_to_internet?
+    if interactive_mode
+      connected
+    else
+      puts (post_processor ? post_processor.(connected) : "Connected to Internet: #{connected}")
+    end
+  end
+
+
+  def cmd_co(network, password = nil)
+    model.connect(network, password)
+  end
+
+
+  def cmd_cy
+    model.cycle_network
+  end
+
+
+  def cmd_d
+    model.disconnect
+  end
+
+
+  def cmd_h
+    print_help
+  end
+
+
+  def cmd_i
+    info = model.wifi_info
+    if interactive_mode
+      info
+    else
+      if post_processor
+        puts post_processor.(info)
+      else
+        puts fancy_string(info)
+      end
+    end
+  end
+
+
+  def cmd_lsa
+    info = model.available_network_info
+    if interactive_mode
+      info
+    else
+      if post_processor
+        puts post_processor.(info)
+      else
+        message = model.wifi_on? ? fancy_string(info) : "Wifi is off, cannot see available networks."
+        puts(message)
+      end
+    end
+  end
+
+
+  def cmd_n
+    name = model.connected_network_name
+    if interactive_mode
+      name
+    else
+      display_name = name ? name : '[none]'
+      puts (post_processor ? post_processor.(name) : %Q{Network (SSID) name: "#{display_name}"})
+    end
+  end
+
+
+  def cmd_of
+    model.wifi_off
+  end
+
+
+  def cmd_on
+    model.wifi_on
+  end
+
+
+  def cmd_pa(network)
+    password = model.preferred_network_password(network)
+
+    if interactive_mode
+      password
+    else
+      if post_processor
+        puts post_processor.(password)
+      else
+        output =  %Q{Preferred network "#{model.connected_network_name}" }
+        output << (password ? %Q{stored password is "#{password}".} : "has no stored password.")
+        puts output
+      end
+    end
+  end
+
+
+  def cmd_pr
+    networks = model.preferred_networks
+    if interactive_mode
+      networks
+    else
+      puts (post_processor ? post_processor.(networks) : fancy_string(networks))
+    end
+  end
+
+
+  def cmd_q
+    quit
+  end
+
+
+  def cmd_r(*options)
+    removed_networks = model.remove_preferred_networks(*options)
+    if interactive_mode
+      removed_networks
+    else
+      puts (post_processor ? post_processor.(removed_networks) : "Removed networks: #{removed_networks.inspect}")
+    end
+  end
+
+
+  def cmd_t(*options)
+    target_status = options[0].to_sym
+    wait_interval_in_secs = (options[1] ? Float(options[1]) : nil)
+    model.till(target_status, wait_interval_in_secs)
+  end
+
+
+  def cmd_w
+    on = model.wifi_on?
+    if interactive_mode
+      on
+    else
+      puts (post_processor ? post_processor.(on) : "Wifi on: #{on}")
+    end
+  end
+
+
+  def cmd_x
+    quit
+  end
+
+
+  def commands
+    @commands_ ||= [
+        Command.new('a',   'avail_nets',    -> (*_options) { cmd_a             }),
+        Command.new('ci',  'ci',            -> (*_options) { cmd_ci            }),
+        Command.new('co',  'connect',       -> (*options)  { cmd_co(*options)  }),
+        Command.new('cy',  'cycle',         -> (*_options) { cmd_cy            }),
+        Command.new('d',   'disconnect',    -> (*_options) { cmd_d             }),
+        Command.new('h',   'help',          -> (*_options) { cmd_h             }),
+        Command.new('i',   'info',          -> (*_options) { cmd_i             }),
+        Command.new('l',   'ls_avail_nets', -> (*_options) { cmd_lsa           }),
+        Command.new('n',   'network_name',  -> (*_options) { cmd_n             }),
+        Command.new('of',  'off',           -> (*_options) { cmd_of            }),
+        Command.new('on',  'on',            -> (*_options) { cmd_on            }),
+        Command.new('pa',  'password',      -> (*options)  { cmd_pa(*options)  }),
+        Command.new('pr',  'pref_nets',     -> (*_options) { cmd_pr            }),
+        Command.new('q',   'quit',          -> (*_options) { cmd_q             }),
+        Command.new('r',   'rm_pref_nets',  -> (*options)  { cmd_r(*options)   }),
+        Command.new('t',   'till',          -> (*options)  { cmd_t(*options)   }),
+        Command.new('w',   'wifion',        -> (*_options) { cmd_w             }),
+        Command.new('x',   'xit',           -> (*_options) { cmd_x             })
+    ]
+  end
+
+
+  def find_command_action(command_string)
+    result = commands.detect do |cmd|
+      cmd.max_string.start_with?(command_string) \
+      && \
+      command_string.length >= cmd.min_string.length  # e.g. 'c' by itself should not work
+    end
+
+    result ? result.action : nil
+  end
+
+
+  # If a post-processor has been configured (e.g. YAML or JSON), use it.
+  def post_process(object)
+    post_processor ? post_processor.(object) : object
+  end
+
+
+
+  def post_processor
+    options.post_processor
+  end
+
+
+  def call
+    validate_command_line
+    begin
+      process_command_line(ARGV[0], ARGV[1..-1])
+    rescue BadCommandError => error
+      separator_line = "! #{'-' * 75} !\n"
+      puts '' << separator_line << error.to_s << "\n" << separator_line
+      exit(-1)
+    end
+  end
+end
+end