assemblr 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a56be997b4579f72b563f67e40f81a2aaaec974dc2568a345528e9171b0813c1
-  data.tar.gz: 2d08815cb4b1c2d2245c75a9337a7586dfa2ef7e646ed726d8ed6527c90166c6
+  metadata.gz: 864016a190bb0067cd305a9824003a3cca4be4dd5eab9eb92b4f1e88ea388789
+  data.tar.gz: '08f75aa401dd8863a95897c07eacfffa5364b8cbefff9f39711167ff803867c9'
 SHA512:
-  metadata.gz: 7571588a2718e3ed241d328b5d25d9fd9efb75054bee707c27d65b549e3dd944e909dc715d93958a0eeb18386cffead01d92306a800a3957d6b4dae5aeac9fa9
-  data.tar.gz: cb10006737feca4ee02d42af22b6d06e9fc4fea7ae258d374f27e3363c37bcc03abf3877280cf29812d52ff9ae2fc2d4f5f5677752468dbca6d5f29b82f03a70
+  metadata.gz: 3d35cb5c921b0da7ffd6440aafe890e14c113dbee161be2351161c79c56f9ac10d228688c3bcbfe70181068ce159da0a7349032b6697b88d3eb57a71f1e3506f
+  data.tar.gz: 2b59abd44694032c93d6018b5698d9eb227fe5019c4aad8914805f32992bd7dfd60ab0015f4923e207b29f085bc44eafbc44c319057fa5286e8abe0260306ff5

data/.gitignore

@@ -9,5 +9,7 @@
 /.idea/
 /examples/
 
+*.gem
+
 /Gemfile.lock
 /.rakeTasks

data/README.md

@@ -22,45 +22,33 @@ Or install it yourself as:
 
 ## Usage
 
-This is an example of a simple assemblr script:
+Assemblr is separated into modules. The core module contains simple logging
+methods since they're needed by all other modules. It gets automatically
+imported when requiring any sub-modules.
 
-```ruby
-# frozen_string_literal: true
-
-require 'assemblr'
-
-# Configuration options. The values listed below are the defaults for assemblr.
-set :default_user, 'root'     # set the default user nodes are assigned to
-set :default_group, 'default' # set the default group nodes are assigned to
-set :log, true                # turn on or off built-in logging.
-set :quit_on_error, true      # quit if anything goes wrong.
+Here are the currently existing modules (although none of them are close to
+finished):
 
-group :dev_servers do
-  # Define nodes. All nodes defined in this block will be added to the
-  # specified group (:dev_servers). After the block ends, the default user and
-  # group will be restored for any other top-level node definitions.
-  node '10.0.0.173'
-  node '10.0.0.332'
-  node '10.0.1.22'
-end
+- `assemblr/shell`
+- `assemblr/network`
+- `assemblr/remote`
 
-node '10.0.0.33' # assigned to group :default and user 'root' as per the
-                 # defaults
+There are currently two styles available to call the methods defined in these
+modules:
 
-group :dev_servers do
-  upload 'Gemfile', '/tmp/Gemmm' # upload a file to all nodes in a group
-  upload 'lib', '/tmp',
-         recursive: true # upload a directory to all nodes in a group
-
-  remote_exec 'echo "Hello, world!"'
-end
+```ruby
+require 'assemblr/shell'
 
-upload_to '10.0.2.43', 'root', 'message.txt', '/home/user/message.txt'
-result = remote_exec_on 'ruby', inject: ['puts "Hello, world!"', 'exit']
+# Style 1
+Shell.exec 'my_command'
 
-puts result
+# Style 2
+shell_exec 'my_command'
 ```
 
+Both styles are automatically imported into the main scope when the file is
+required.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. You can

data/lib/assemblr.rb

@@ -1,275 +1,106 @@
 # frozen_string_literal: true
 
-require 'assemblr/version'
-require 'assemblr/logging'
-require 'assemblr/utilities'
+$VERBOSE = nil
 
-require 'open3'
-require 'net/ssh'
-require 'net/scp'
+require 'tty-logger'
 
+##
+# Define the core Assemblr methods.
 module Assemblr
-  $VERBOSE = nil # turn off warnings from external libraries
+  @@options = []
+  @@error_hook = -> {}
 
-  # Local variables are prefixed with an 'm' for 'Module' as to not clash with
-  # method names.
-  m_nodes = []
-  m_current_group = 'default'
-  m_current_user = 'root'
+  def set_option(key, value)
+    return unless @@options.include?(key.to_sym)
 
-  ##
-  # Set a configuration option.
-  #
-  # Available options are:
-  #
-  # - *default_user*  - the default user to assign nodes to
-  # - *default_group* - the default group to assign nodes to
-  # - *log*           - turn on or off logging
-  # - *quit_on_error* - quit if any error occur
-  #
-  # @return [void]
-  define_method :set do |key, value|
-    options = %i[log quit_on_error default_user default_group]
-    unless options.include?(key)
-      raise ArgumentError, "#{key} is not a valid option"
-    end
-
-    key = :current_user if key == :default_user
-    key = :current_group if key == :default_group
-
-    info %(config: set "#{key}" to "#{value}")
-    eval "m_#{key} = value", binding, __FILE__, __LINE__
+    Assemblr.class_variable_set("@@#{key}", value)
   end
 
-  ##
-  # @!method local_exec(cmd, inject: [])
-  # Execute a command locally.
-  #
-  # @param cmd [String] the command to run locally
-  # @param inject [Array<String>] strings to inject into stdin
-  #
-  # @return [Array(String, Process::Status)]
-  define_method :local_exec do |cmd, inject: []|
-    log_string = "running `#{cmd}` locally"
-    log_string += " with these inputs: #{inject}" unless inject.empty?
-    info log_string
-
-    result = ''
-    status = nil
-    Open3.popen2e(cmd) do |i, o, wait|
-      inject.each do |line|
-        line = line.strip
-        i.write line + "\n"
-      end
-      i.close
-      result = o.read
-      status = wait.value
-    end
-
-    if status.exitstatus != 0
-      code = status.exitstatus
-      error "local command `#{cmd}` exited with a status of #{code}"
-    else
-      success "local command `#{cmd}` executed successfully"
-    end
-
-    return result, status
+  def get_option(key)
+    Assemblr.class_variable_get("@@#{key}")
   end
 
-  ##
-  # Execute a command on a remote machine using SSH. It returns the combined
-  # stdout and stderr data.
-  #
-  # @param ip [String] the ip of the node to run the command on
-  # @param user [String] the user to log in as
-  # @param cmd [String] the command to execute remotely
-  # @param inject [Array<String>] strings to inject into stdin
-  #
-  # @return [String]
-  # @return [Array<String>]
-  def remote_exec_on(ip, user, cmd, inject: [])
-    info "attempting to execute `#{cmd}` on #{user}@#{ip}"
-
-    result = ''
-    Net::SSH.start(ip, user) do |ssh|
-      ch = ssh.open_channel do |ch|
-        ch.exec(cmd) do |ch, success|
-          error "unable to execute `#{cmd}` on #{user}@#{ip}" unless success
-
-          # Collect stdout data.
-          ch.on_data do |_, data|
-            result += data if data.is_a?(String)
-          end
-
-          # Collect stderr data.
-          ch.on_extended_data do |_, _, data|
-            result += data if data.is_a?(String)
-          end
-
-          inject.each do |line|
-            ch.send_data(line + "\n")
-          end
-
-          ch.on_request 'exit-status' do |_, data|
-            code = data.read_long
-            if code.zero?
-              success "`#{cmd}` executed successfully on #{user}@#{ip}"
-            else
-              error "`#{cmd}` returned status code #{code} on #{user}@#{ip}"
-            end
-          end
-        end
-      end
-
-      ch.wait
-    end
-    result
+  def define_option(name, value)
+    Assemblr.class_variable_set("@@#{name}", value)
+    @@options << name.to_sym
   end
 
-  ##
-  # Upload a file to a node.
-  #
-  # @param ip [String] the node to upload to
-  # @param user [String] the user to authenticate as
-  # @param src [String] the file to upload
-  # @param dest [String] the location to upload to
-  # @param recursive [Bool] recursively upload files in a directory
-  # @param timeout [Integer] how many seconds to wait before throwing an error
-  #
-  # @return [void]
-  def upload_to(ip, user, src, dest, recursive: false, timeout: 5)
-    info %(attempting to upload "#{src}" to #{user}@#{ip}:#{dest})
-    Timeout.timeout timeout do
-      Net::SCP.upload!(ip, user, src, dest, recursive: recursive)
-    end
-  rescue StandardError
-    error %(failed to upload "#{src}" to #{user}@#{ip}:#{dest})
-  rescue Timeout::Error
-    error %(failed to upload "#{src}" to #{user}@#{ip}:#{dest} within #{timeout} seconds)
-  else
-    success %(uploaded "#{src}" to #{user}@#{ip}:#{dest})
+  def options
+    Assemblr.class_variable_get('@@options')
   end
 
-  ##
-  # @!method current_nodes()
-  # Get all nodes in the current group.
-  #
-  # @return [void]
-  define_method :current_nodes do
-    return nodes if m_current_group == 'all'
-
-    nodes.select { |n| n[:group] == m_current_group }
+  def error_hook
+    @@on_error
   end
 
-  ##
-  # Execute a command on all machines within the current group.
-  #
-  # @param cmd [String] the command to execute
-  # @param inject [Array<String>] strings to inject into stdin
-  #
-  # @return [String] the combined output of the command
-  def remote_exec(cmd, inject: [])
-    results = []
-    current_nodes.each do |n|
-      result = remote_exec_on(n[:ip], n[:user], cmd, inject: inject)
-      results << result
-    end
-    results
+  def on_error(&block)
+    @@on_error = block
   end
 
   ##
-  # Upload a file or directory to all machines within the current group.
-  #
-  # @param src [String] the file to upload
-  # @param dest [String] the location to upload the file to
-  # @param recursive [Bool] recursively upload files in a directory
-  # @param timeout [Integer] how many seconds to wait before throwing an error
-  #
-  # @return [void]
-  def upload(src, dest, recursive: false, timeout: 5)
-    current_nodes.each do |n|
-      upload_to(n[:ip], n[:user], src, dest, recursive: recursive)
-    end
+  # Generates method definitions in all supported styles.
+  def expose_method(name)
+    prefix = to_s.downcase.gsub('::', '_').delete_prefix('assemblr_')
+    eval "#{self}.define_method(:#{prefix}_#{name}, &#{self}.method(:#{name}))"
+    eval "#{self}.define_singleton_method(:#{name}, &#{self}.method(:#{name}))"
   end
+end
 
-  ##
-  # @!method group(group, &block)
-  # Temporarily change current_group to refer to the specified group while
-  # within the passed block.
-  #
-  # @param group [Symbol] the group to temporarily switch to
-  #
-  # @return [void]
-  define_method :group do |group, &block|
-    info %(entered group block with group "#{group}")
-
-    # Temporarily switch to the target group.
-    old_current_group = m_current_group
-    m_current_group = group.to_s
-
-    block.call
-
-    m_current_group = old_current_group
-
-    info %(exited group block with group "#{group}")
-  end
+include Assemblr
 
+module Assemblr
   ##
-  # @!method current_group
-  # Get the current default group.
-  #
-  # @return [String]
+  # Define some quick-and-easy logging methods.
+  module Log
+    define_option :log, true
+    define_option :log_error_hook, true
 
-  ##
-  # @!method current_user
-  # Get the current default user.
-  #
-  # @return [String]
-  %w[group user].each do |item|
-    define_method "current_#{item}" do
-      eval "m_current_#{item}"
+    TTYLogger = TTY::Logger.new do |config|
+      config.metadata = %i[time date]
     end
-  end
 
-  ##
-  # @!method node(ip, group: current_group, user: current_user)
-  # Add a node to the list of nodes.
-  #
-  # @param ip [String] the ip address of the node
-  # @param group [Symbol] the group to assign the node to
-  # @param user [String] the user to associate with the node
-  #
-  # @return [Hash{ip=>String, group=>String, user=>String}] the added node
-  define_method :node do |ip, group: m_current_group, user: m_current_user|
-    group = group.to_s
-    if group == 'all'
-      error = ArgumentError.new('nodes can not be assigned to the "all" group')
-      raise error
+    def self.included(_)
+      expose_method :info
+      expose_method :success
+      expose_method :warn
+      expose_method :error
     end
 
-    l_node = { ip: ip, group: group, user: user }
-    m_nodes << l_node
-    info "added node: #{l_node}"
-
-    l_node
-  end
-
-  ##
-  # @!method nodes()
-  # Get all registered nodes.
-  #
-  # @return [Array<Hash{ip=>String, group=>String, user=>String}>]
-  define_method :nodes do
-    m_nodes
-  end
+    class << self
+      ##
+      # @!method info(message)
+      # Logs an info message.
+      #
+      # @return [void]
+
+      ##
+      # @!method success(message)
+      # Logs a success message.
+      #
+      # @return [void]
+
+      ##
+      # @!method warn(message)
+      # Logs a warning message.
+      #
+      # @return [void]
+      %i[info success warn].each do |level|
+        define_method level do |*args, &block|
+          TTYLogger.send(level, *args, &block) if get_option(:log)
+        end
+      end
 
-  define_method :nodes_reachable? do
-    reachable = true
-    m_nodes.each do |node|
-      reachable &&= reachable?(node[:ip])
+      ##
+      # @!method error(message)
+      # Logs a error message. If configured, this will call the on_error proc
+      #
+      # @return [void]
+      define_method :error do |*args, &block|
+        TTYLogger.send(:error, *args, &block) if get_option(:log)
+        error_hook.call if get_option(:log_error_hook)
+      end
     end
-    reachable
   end
 end
 
-extend Assemblr
+include Assemblr::Log

data/lib/assemblr/network.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+$VERBOSE = nil
+
+require 'assemblr'
+
+require 'socket'
+require 'net/ping'
+
+module Assemblr
+  ##
+  # Defines methods for common network functions.
+  module Network
+    def self.included(_)
+      expose_method :local_ip
+      expose_method :ip_reachable?
+    end
+
+    class << self
+      ##
+      # Retrieve the first ip address that is not '127.0.0.1' on the local
+      # machine.
+      #
+      # @param pattern [Regexp] a pattern to test the IPs against
+      #
+      # @return [String]
+      def local_ip(pattern = //)
+        Socket.ip_address_list.each do |ip|
+          address = ip.ip_address
+          next if address == '127.0.0.1'
+          return address if address.match?(pattern)
+        end
+        ''
+      end
+
+      ##
+      # Check if a remote ip can be contacted.
+      #
+      # @return [Boolean]
+      def ip_reachable?(ip)
+        external = Net::Ping::External.new(ip)
+
+        log_info %(attempting to contact host "#{ip}")
+        reachable = external.ping || external.ping6
+        if reachable
+          log_success %(host "#{ip}" is reachable)
+        else
+          log_error %(unable to contact host "#{ip}")
+        end
+
+        reachable
+      end
+    end
+  end
+end
+
+include Assemblr::Network

data/lib/assemblr/remote.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require 'assemblr'
+
+require 'timeout'
+require 'net/ssh'
+require 'net/scp'
+
+module Assemblr
+  ##
+  # Defines methods to handle interacting with remote nodes.
+  module Remote
+    @@nodes = []
+
+    define_option :remote_default_group, :default
+    define_option :remote_default_user, 'root'
+
+    def self.included(_)
+      expose_method :group
+      expose_method :upload
+      expose_method :exec
+      expose_method :current_nodes
+      expose_method :node
+      expose_method :nodes
+    end
+
+    class << self
+      ##
+      # Defines methods availabile only while in a group block.
+      module Group
+        def self.remote_upload(src, dest, recursive: false, timeout: 5)
+          Remote.current_nodes.each do |n|
+            Remote.upload(n[:ip], n[:user], src, dest,
+                          recursive: recursive,
+                          timeout: timeout)
+          end
+        end
+
+        def self.remote_exec(cmd, inject: [])
+          results = []
+          Remote.current_nodes.each do |n|
+            result = Remote.remote_exec(n[:ip], n[:user], cmd, inject: inject)
+            results << result
+          end
+          results
+        end
+      end
+
+      # Execute a command on a remote machine using SSH. It returns the
+      # combined stdout and stderr data.
+      #
+      # @param ip [String] the ip of the node to run the command on
+      # @param user [String] the user to log in as
+      # @param cmd [String] the command to execute remotely
+      # @param inject [Array<String>] strings to inject into stdin
+      #
+      # @return [String]
+      def exec(ip, user, cmd, inject: [])
+        log_info "attempting to execute `#{cmd}` on #{user}@#{ip}"
+
+        result = ''
+        exit_code = 0
+        Net::SSH.start(ip, user) do |ssh|
+          ch = ssh.open_channel do |ch|
+            ch.exec(cmd) do |ch, success|
+              log_error "unable to execute `#{cmd}` on #{user}@#{ip}" unless success
+
+              # Collect stdout data.
+              ch.on_data do |_, data|
+                result += data if data.is_a?(String)
+              end
+
+              # Collect stderr data.
+              ch.on_extended_data do |_, _, data|
+                result += data if data.is_a?(String)
+              end
+
+              inject.each do |line|
+                ch.send_data(line + "\n")
+              end
+
+              ch.on_request 'exit-status' do |_, data|
+                exit_code = data.read_long
+                if exit_code.zero?
+                  log_success "`#{cmd}` executed successfully on #{user}@#{ip}"
+                else
+                  log_error "`#{cmd}` returned status code #{exit_code} on #{user}@#{ip}"
+                end
+              end
+            end
+          end
+
+          ch.wait
+        end
+        [result, exit_code]
+      end
+
+      ##
+      # Return all nodes within the current default group.
+      #
+      # @return [Array<Hash{ip=>String, group=>String, user=>String}>]
+      def current_nodes
+        return nodes if get_option(:remote_default_group) == 'all'
+
+        @@nodes.select { |n| n[:group] == get_option(:remote_default_group).to_s }
+      end
+
+      ##
+      # Temporarily change the default group to refer to the specified group
+      # while within the passed block.
+      #
+      # This method also changes the behavior of `remote_exec` and
+      # `remote_upload` while within the given block. Both functions don't take
+      # an IP # and a user, as they collect the information for all nodes
+      # within the group. In that case, the return value is an array of the
+      # results given by each node.
+      #
+      # @param group [Symbol] the group to temporarily switch to
+      #
+      # @return [void]
+      def group(group, &block)
+        log_info %(entered group block with group "#{group}")
+
+        # Temporarily switch to the target group.
+        old_default_group = get_option(:remote_default_group)
+        set_option(:remote_default_group, group.to_s)
+
+        Group.class_eval(&block)
+
+        set_option(:remote_default_group, old_default_group)
+
+        log_info %(exited group block with group "#{group}")
+      end
+
+      ##
+      # Upload a file or directory to a node.
+      #
+      # @param ip [String] the node to upload to
+      # @param user [String] the user to authenticate as
+      # @param src [String] the file to upload
+      # @param dest [String] the location to upload to
+      # @param recursive [Bool] recursively upload files in a directory
+      # @param timeout [Integer] how many seconds to wait before throwing an error
+      #
+      # @return [void]
+      def upload(ip, user, src, dest, recursive: false, timeout: 5)
+        log_info %(attempting to upload "#{src}" to #{user}@#{ip}:#{dest})
+        Timeout.timeout timeout do
+          Net::SCP.upload!(ip, user, src, dest, recursive: recursive)
+        end
+      rescue Timeout::Error
+        log_error %(failed to upload "#{src}" to #{user}@#{ip}:#{dest} within #{timeout} seconds)
+      rescue StandardError
+        log_error %(failed to upload "#{src}" to #{user}@#{ip}:#{dest})
+      else
+        log_success %(uploaded "#{src}" to #{user}@#{ip}:#{dest})
+      end
+
+      ##
+      # Add a node to the list of nodes.
+      #
+      # @param ip [String] the ip address of the node
+      # @param group [Symbol] the group to assign the node to
+      # @param user [String] the user to associate with the node
+      #
+      # @return [Hash{ip=>String, group=>String, user=>String}] the added node
+      def node(ip,
+               group: get_option(:remote_default_group),
+               user: get_option(:remote_default_user))
+        group = group.to_s
+        if group == 'all'
+          message = 'nodes can not be assigned to the "all" group'
+          error = ArgumentError.new(message)
+          raise error
+        end
+
+        l_node = { ip: ip, group: group, user: user }
+        @@nodes << l_node
+        log_info "added node: #{l_node}"
+
+        l_node
+      end
+
+      ##
+      # Get all registered nodes.
+      #
+      # @return [Array<Hash{ip=>String, group=>String, user=>String}>]<Paste>
+      def nodes
+        @@nodes
+      end
+    end
+  end
+end
+
+include Assemblr::Remote

data/lib/assemblr/shell.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'assemblr'
+
+require 'open3'
+
+module Assemblr
+  ##
+  # Defines methods for common shell commands.
+  module Shell
+    def self.included(_)
+      expose_method :exec
+    end
+
+    class << self
+      # Execute a command locally.
+      #
+      # @param cmd [String] the command to run locally
+      # @param inject [Array<String>] strings to inject into stdin
+      #
+      # @return [Array(String, Process::Status)]
+      def exec(cmd, inject: [])
+        log_string = "running `#{cmd}` locally"
+        log_string += " with these inputs: #{inject}" unless inject.empty?
+        log_info log_string
+
+        result = ''
+        status = nil
+        Open3.popen2e(cmd) do |i, o, wait|
+          inject.each do |line|
+            line = line.strip
+            i.write line + "\n"
+          end
+          i.close
+          result = o.read
+          status = wait.value
+        end
+
+        if status.exitstatus != 0
+          code = status.exitstatus
+          log_error "local command `#{cmd}` exited with a status of #{code}"
+        else
+          log_success "local command `#{cmd}` executed successfully"
+        end
+
+        [result, status]
+      end
+    end
+  end
+end
+
+include Assemblr::Shell

data/lib/assemblr/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Assemblr
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: assemblr
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Ryan Burmeister-Morrison
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-03-08 00:00:00.000000000 Z
+date: 2020-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -110,8 +110,9 @@ files:
 - bin/console
 - bin/setup
 - lib/assemblr.rb
-- lib/assemblr/logging.rb
-- lib/assemblr/utilities.rb
+- lib/assemblr/network.rb
+- lib/assemblr/remote.rb
+- lib/assemblr/shell.rb
 - lib/assemblr/version.rb
 homepage: https://github.com/rburmorrison/assemblr
 licenses:

data/lib/assemblr/logging.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require 'tty-logger'
-
-module Assemblr
-  Logger = TTY::Logger.new do |config|
-    config.metadata = %i[time date]
-  end
-
-  m_log = true
-  m_quit_on_error = true
-
-  ##
-  # @!method info(message)
-  # Logs an info message.
-  #
-  # @return [void]
-
-  ##
-  # @!method success(message)
-  # Logs a success message.
-  #
-  # @return [void]
-
-  ##
-  # @!method warn(message)
-  # Logs a warning message.
-  #
-  # @return [void]
-  %i[info success warn].each do |level|
-    define_method level do |*args, &block|
-      return unless m_log
-
-      Logger.send(level, *args, &block)
-    end
-  end
-
-  ##
-  # @!method error(message)
-  # Logs a error message. If configured, this will end the task with error code
-  # 1.
-  #
-  # @return [void]
-  define_method :error do |*args, &block|
-    Logger.send(:error, *args, &block) if m_log
-    exit 1 if m_quit_on_error
-  end
-end

data/lib/assemblr/utilities.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require 'socket'
-require 'net/ping'
-
-##
-# A collection of utility functions for assemblr.
-module Assemblr
-  ##
-  # Retrieve the first ip address that is not '127.0.0.1' on the local machine.
-  #
-  # @param pattern [Regexp] a pattern to test the ips against
-  def get_local_ip(pattern = //)
-    Socket.ip_address_list.each do |ip|
-      address = ip.ip_address
-      next if address == '127.0.0.1'
-      return address if address.match?(pattern)
-    end
-    ''
-  end
-
-  ##
-  # Check if a remote machine can be contacted.
-  #
-  # @return [Bool]
-  def reachable?(ip)
-    external = Net::Ping::External.new(ip)
-
-    info %(attempting to contact host "#{ip}"...)
-    reachable = external.ping || external.ping6
-    if reachable
-      success %(host "#{ip}" is reachable)
-    else
-      error %(unable to contact host "#{ip}")
-    end
-
-    reachable
-  end
-end