smartdust-client 1.1.0

data/lib/stf/interactor/start_debug_session_interactor.rb

@@ -0,0 +1,156 @@
+require 'ADB'
+
+require 'stf/client'
+require 'stf/log/log'
+require 'stf/model/device_list'
+
+module Stf
+  class StartDebugSessionInteractor
+
+    include Log
+    include ADB
+
+    def execute(opts = {})
+      all_flag = opts[:all]
+      nodaemon_flag = opts[:nodaemon]
+      filter = opts[:filter]
+      max_n = opts[:n].to_i > 0 ? opts[:n].to_i : 1
+      start_timeout = opts[:starttime].to_i > 0 ? opts[:starttime].to_i : 120
+      session = opts[:worktime].to_i > 0 ? opts[:session].to_i : 10800
+      min_n = opts[:min].to_s.empty? ? (max_n + 1) / 2 : [opts[:min].to_i, max_n].min
+      healthcheck = opts[:health]
+      force_filter = opts[:forcefilter]
+
+      DI[:demonizer].kill unless opts[:nokill]
+
+      wanted = nodaemon_flag ? max_n : min_n
+
+      begin
+        connect_loop(all_flag: all_flag,
+                     wanted: wanted,
+                     filter: filter,
+                     force_filter: force_filter,
+                     healthcheck: healthcheck,
+                     delay: 5,
+                     timeout: start_timeout)
+
+      rescue SignalException => e
+        logger.info "Caught signal \"#{e.message}\""
+        DI[:stop_all_debug_sessions_interactor].execute
+        return false
+      rescue Exception => e
+        logger.info "Exception \"#{e.message}\" during initial connect loop"
+        DI[:stop_all_debug_sessions_interactor].execute
+        return false
+      end
+
+      connected_count = count_connected_devices(filter)
+      logger.info "Lower quantity achieved, already connected #{connected_count}"
+
+      return true if nodaemon_flag
+
+      # will be daemon here
+      DI[:demonizer].run do
+        connect_loop(all_flag: all_flag,
+                     wanted: max_n,
+                     filter: filter,
+                     force_filter: force_filter,
+                     healthcheck: healthcheck,
+                     daemon_mode: true,
+                     delay: 30,
+                     timeout: session)
+
+        DI[:stop_all_debug_sessions_interactor].execute(byFilter: filter, nokill: true)
+      end
+
+      return true
+    end
+
+    def connect_loop(all_flag: false,
+                     wanted: 1,
+
+                     filter: nil,
+                     force_filter: false,
+                     healthcheck: nil,
+
+                     daemon_mode: false,
+                     delay: 5,
+                     timeout: 120)
+      finish_time = Time.now + timeout
+      one_time_mode = !daemon_mode
+
+      while true do
+        cleanup_disconnected_devices(filter, force_filter, healthcheck)
+
+        if one_time_mode && Time.now > finish_time
+          raise "Connect loop timeout reached"
+        end
+
+        all_devices = DeviceList.new(DI[:stf].get_devices)
+        stf_devices = all_devices.select_ready_to_connect
+        stf_devices = stf_devices.by_filter(filter) if filter
+        stf_devices = stf_devices.select_healthy_for_connect(healthcheck) if healthcheck
+
+        if all_flag
+          to_connect = stf_devices.size
+        else
+          connected = devices & all_devices.as_connect_url_list
+          to_connect = wanted - connected.size
+        end
+
+        return if one_time_mode && to_connect <= 0
+
+        if to_connect > 0
+          if stf_devices.empty?
+            logger.error 'There is no available devices with criteria ' + filter
+          else
+            random_device = stf_devices.asArray.sample
+            DI[:start_one_debug_session_interactor].execute(random_device)
+            next
+          end
+        end
+
+        sleep delay
+      end
+    end
+
+    def count_connected_devices(filter)
+      stf_devices = DeviceList.new(DI[:stf].get_user_devices)
+      stf_devices = stf_devices.by_filter(filter) if filter
+      connected = devices & stf_devices.as_connect_url_list
+      connected.size
+    end
+
+    def cleanup_disconnected_devices(filter, force_filter, healthcheck)
+      to_disconnect = []
+      stf_devices = DeviceList.new(DI[:stf].get_user_devices)
+
+      if filter && force_filter
+        disconnect_because_filter = stf_devices.except_filter(filter).as_connect_url_list
+        unless disconnect_because_filter.empty?
+          logger.info 'will be disconnected by filter: ' + disconnect_because_filter.join(',')
+          to_disconnect += disconnect_because_filter
+        end
+      end
+
+      if healthcheck
+        disconnect_by_health = stf_devices.select_not_healthy(healthcheck).as_connect_url_list
+        unless disconnect_by_health.empty?
+          logger.info 'will be disconnected by health check: ' + disconnect_by_health.join(',')
+          to_disconnect += disconnect_by_health
+        end
+      end
+
+      dead_persons = stf_devices.as_connect_url_list - devices
+      unless dead_persons.empty?
+        logger.info 'will be disconnected because not present locally: ' + dead_persons.join(',')
+        to_disconnect += dead_persons
+      end
+
+      to_disconnect.reject {|url| url.to_s.empty?}.uniq.each do |url|
+        logger.info 'Cleanup the device ' + url.to_s
+        DI[:stop_debug_session_interactor].execute(url)
+      end
+    end
+  end
+end

data/lib/stf/interactor/start_one_debug_session_interactor.rb

@@ -0,0 +1,76 @@
+require 'di'
+require 'ADB'
+
+require 'stf/client'
+require 'stf/log/log'
+
+module Stf
+  class StartOneDebugSessionInteractor
+
+    include Log
+    include ADB
+
+    def execute(device)
+      return false if device.nil?
+      serial = device.serial
+
+      begin
+        success = DI[:stf].add_device serial
+        if success
+          logger.info "Device added #{serial}"
+        else
+          logger.error "Can't add device #{serial}"
+          raise
+        end
+
+        result = DI[:stf].start_debug serial
+        if result.success
+          logger.info "Debug started #{serial}"
+        else
+          logger.error "Can't start debugging session for device #{serial}"
+          raise
+        end
+
+        provider = device.getValue "provider"
+        provider_ip = provider["ip"]
+        remote_connect_url_split = result.remoteConnectUrl.split ":"
+        remote_connect_port = remote_connect_url_split[1]
+        result = DI[:stf].open_tunnel provider_ip, remote_connect_port.to_i
+        if result.success
+          logger.info "Opened tunnel to provider with IP #{provider_ip}"
+        else
+          logger.error "Can't open tunnel to provider with IP #{provider_ip}"
+          raise
+        end
+        remote_connect_tunneled_url = DI[:device_enhancer].get_tunneled_remote_connect_url(device)
+        logger.info remote_connect_tunneled_url
+        execute_adb_with 30, "connect #{remote_connect_tunneled_url}"
+
+        shell('echo adbtest', {serial: "#{remote_connect_tunneled_url}"}, 30)
+        raise ADBError, "Could not execute shell test" unless stdout_contains "adbtest"
+
+        return true
+
+      rescue StandardError, SignalException => e
+        begin
+          # we will try clean anyway
+          DI[:stf].remove_device serial
+          if test ?d, '/custom-metrics'
+            File.open('/custom-metrics/openstf_connect_fail', 'a') do |f|
+              message = (!e.nil? || !e.message.nil?) ? e.message : ""
+              f.write("openstf_connect_fail,reason=\"#{escape(message)}\",serial=\"#{escape(serial)}\" count=1i #{Time.now.to_i}\n")
+            end
+          end
+        rescue
+        end
+
+        logger.error "Failed to connect to #{serial}: " + e&.message
+        return false
+      end
+    end
+
+    def escape(s)
+      s.gsub(/["]/, '\"').gsub(/[ ]/, '\ ').gsub(/[=]/, '\=').gsub(/[,]/, '\,')
+    end
+  end
+end

data/lib/stf/interactor/stop_all_debug_sessions_interactor.rb

@@ -0,0 +1,27 @@
+require 'di'
+require 'ADB'
+
+require 'stf/client'
+require 'stf/log/log'
+require 'stf/interactor/stop_debug_session_interactor'
+require 'stf/model/device_list'
+
+module Stf
+  class StopAllDebugSessionsInteractor
+    include Log
+    include ADB
+
+    # byFilter:
+    def execute(options = {})
+      DI[:demonizer].kill unless options[:nokill]
+
+      stf_devices = DeviceList.new(DI[:stf].get_user_devices)
+
+      stf_devices = stf_devices.by_filter options[:byFilter] if options[:byFilter]
+
+      pending_disconnect = stf_devices.as_connect_url_list
+
+      pending_disconnect.each {|d| DI[:stop_debug_session_interactor].execute d}
+    end
+  end
+end

data/lib/stf/interactor/stop_debug_session_interactor.rb

@@ -0,0 +1,54 @@
+require 'di'
+require 'ADB'
+
+require 'stf/client'
+require 'stf/log/log'
+
+module Stf
+  class StopDebugSessionInteractor
+    include Log
+    include ADB
+
+    def execute(remote_connect_url)
+      remote_devices = DI[:stf].get_user_devices
+      device = remote_devices.find {|d| d.remoteConnect == true && DI[:device_enhancer].get_tunneled_remote_connect_url(d).eql?(remote_connect_url)}
+
+      # try to disconnect anyway
+      execute_adb_with 30, "disconnect #{remote_connect_url}"
+
+      if device.nil?
+        logger.error "Device #{remote_connect_url} is not available"
+        return false
+      end
+
+      success = false
+
+      1..10.times do
+        begin
+          success = DI[:stf].stop_debug(device.serial)
+          break if success
+        rescue
+        end
+
+        logger.error 'Can\'t stop debug session. Retrying'
+      end
+
+      1..10.times do
+        begin
+          success = DI[:stf].remove_device(device.serial)
+          break if success
+        rescue
+        end
+        logger.error 'Can\'t remove device from user devices. Retrying'
+      end
+
+      if success
+        logger.info "Successfully removed #{remote_connect_url}"
+      else
+        logger.error "Error removing #{remote_connect_url}"
+      end
+
+      success
+    end
+  end
+end

data/lib/stf/log/log.rb

@@ -0,0 +1,18 @@
+require 'logger'
+
+module Stf
+  module Log
+
+    @@logger = Logger.new(STDOUT)
+    @@logger.level = Logger::INFO
+
+    def logger
+      @@logger
+    end
+
+    def self.verbose(enable)
+      @@logger.level = enable ? Logger::DEBUG : Logger::INFO
+    end
+
+  end
+end

data/lib/stf/model/device.rb

@@ -0,0 +1,75 @@
+module Stf
+  require 'facets/boolean'
+  class Device < OpenStruct
+    def getValue(key)
+      getValueFromObject(self, key)
+    end
+
+    def getKeys
+      getKeysNextLevel('', self)
+    end
+
+    # more pessimistic decision
+    def healthy_for_connect?(pattern)
+      return true if pattern.nil?
+      health = healthy?(pattern)
+      ppp = pattern.split(',')
+      ppp.each do |p|
+        health &&= getValue('battery.temp').to_i < 30 if ['t', 'temp', 'temperature'].include? p
+        health &&= getValue('battery.level').to_f > 30.0 if ['b', 'batt', 'battery'].include? p
+      end
+      health
+    end
+
+    def healthy?(pattern)
+      return true if pattern.nil?
+      ppp = pattern.split(',')
+      health = true
+      ppp.each do |p|
+        health &&= getValue('battery.temp').to_i < 32 if ['t', 'temp', 'temperature'].include? p
+        health &&= getValue('battery.level').to_f > 20.0 if ['b', 'batt', 'battery'].include? p
+        health &&= getValue('network.connected') if ['n', 'net', 'network'].include? p
+        health &&= getValue('network.type') == 'VPN' if ['vpn'].include? p
+        health &&= getValue('network.type') == 'WIFI' if ['wifi'].include? p
+      end
+      health
+    end
+
+    def checkFilter?(filter)
+      return true if filter.nil?
+      key, value = filter.split(':', 2)
+      if value == 'true' || value == 'false'
+        value = value.to_b
+      end
+      getValue(key) == value
+    end
+
+    def getKeysNextLevel(prefix, o)
+      return [] if o.nil?
+
+      o.each_pair.flat_map do |k, v|
+        if v.is_a? OpenStruct
+          getKeysNextLevel(concat(prefix, k.to_s), v)
+        else
+          [concat(prefix, k.to_s)]
+        end
+      end
+    end
+
+    def concat(prefix, key)
+      prefix.to_s.empty? ? key : prefix + '.' + key
+    end
+
+    def getValueFromObject(obj, key)
+      keys = key.split('.', 2)
+      if keys[1].nil?
+        obj[key]
+      else
+        getValueFromObject(obj[keys[0]], keys[1])
+      end
+    end
+
+    private :getValueFromObject, :concat, :getKeysNextLevel
+
+  end
+end

data/lib/stf/model/device_enhancer.rb

@@ -0,0 +1,17 @@
+module Stf
+  class DeviceEnhancer
+    def get_tunneled_remote_connect_url(device)
+      provider = device.provider
+      provider_ip = provider["ip"]
+      result = DI[:stf].start_debug device.serial
+      remote_connect_url_split = result.remoteConnectUrl.split ":"
+      remote_connect_port = remote_connect_url_split[1]
+      result = DI[:stf].check_tunnel provider_ip, remote_connect_port
+      if result.success
+        remote_connect_hostname = remote_connect_url_split[0]
+        remote_connect_hostname + ":" + result.port.to_s
+      else nil
+      end
+    end
+  end
+end

data/lib/stf/model/device_list.rb

@@ -0,0 +1,80 @@
+require 'stf/model/device'
+
+module Stf
+# can not inherite from Array because http://words.steveklabnik.com/beware-subclassing-ruby-core-classes
+  class DeviceList
+    def initialize(devices)
+      if devices.nil?
+        @devices = Array.new
+      else
+        @devices = devices.map {|d| (d.kind_of? Device) ? d : Device.new(d)}
+      end
+    end
+
+    def by_filter(filter)
+      filter ? select {|d| d.checkFilter?(filter)} : []
+    end
+
+    def except_filter(filter)
+      filter ? reject {|d| d.checkFilter?(filter)} : this
+    end
+
+    def select_healthy(pattern)
+      pattern ? select { |d| d.healthy?(pattern) } : this
+    end
+
+    # more pessimistic than healthy()
+    def select_healthy_for_connect(pattern)
+      pattern ? select { |d| d.healthy_for_connect?(pattern) } : this
+    end
+
+    def select_not_healthy(pattern)
+      pattern ? reject { |d| d.healthy?(pattern) } : []
+    end
+
+    def select_ready_to_connect
+      # https://github.com/openstf/stf/blob/93d9d7fe859bb7ca71669f375d841d94fa47d751/lib/wire/wire.proto#L170
+      # enum DeviceStatus {
+      #   OFFLINE = 1;
+      #   UNAUTHORIZED = 2;
+      #   ONLINE = 3;
+      #   CONNECTING = 4;
+      #   AUTHORIZING = 5;
+      # }
+      #
+      # https://github.com/openstf/stf/blob/93d9d7fe859bb7ca71669f375d841d94fa47d751/res/app/components/stf/device/enhance-device/enhance-device-service.js
+      select {|d|
+        d.present == true &&
+            d.status == 3 &&
+            d.ready == true &&
+            d.using == false &&
+            d.owner.nil?
+      }
+    end
+
+    def as_connect_url_list
+      @devices.reject { |d| d.remoteConnectUrl.nil? || d.remoteConnectUrl.empty? }
+              .map{|d| DI[:device_enhancer].get_tunneled_remote_connect_url(d)}
+    end
+
+    def select
+      DeviceList.new(@devices.select {|d| yield(d)})
+    end
+
+    def reject
+      DeviceList.new(@devices.select {|d| !yield(d)})
+    end
+
+    def empty?
+      @devices.empty?
+    end
+
+    def size
+      @devices.size
+    end
+
+    def asArray
+      @devices
+    end
+  end
+end

data/lib/stf/system/demonizer.rb

@@ -0,0 +1,20 @@
+module Stf
+  class Demonizer
+    def initialize(dante, opts = {})
+      @dante = dante
+
+      @pid_path = opts[:pid_path].to_s.empty? ? '/tmp/stf-client.pid' : opts[:pid_path]
+      @log_path = opts[:log_path].to_s.empty? ? '/tmp/stf-client.log' : opts[:log_path]
+    end
+
+    def run
+      @dante.execute(daemonize: true,
+                     pid_path: @pid_path,
+                     log_path: @log_path) {yield}
+    end
+
+    def kill
+      @dante.execute(kill: true, pid_path: @pid_path)
+    end
+  end
+end

data/lib/stf/validate/uri_validator.rb

@@ -0,0 +1,7 @@
+module Stf
+  class URIValidator
+    def validate(uri)
+      return (uri =~ /\A#{URI::regexp(%w(http https))}\z/) != nil
+    end
+  end
+end

data/lib/stf/version.rb

@@ -0,0 +1,3 @@
+module Stf
+  VERSION = '1.1.0'
+end

data/lib/stf/view/cli.rb

@@ -0,0 +1,121 @@
+module Stf
+  module CLI
+    require 'di'
+    require 'gli'
+
+    include GLI::App
+
+    extend self
+
+    program_desc "Smartdust Lab client (version #{Stf::VERSION})"
+
+    desc 'Be verbose'
+    switch [:v, :verbose]
+
+    desc 'PID file'
+    flag [:pid]
+
+    desc 'Log file'
+    flag [:log]
+
+    desc 'Authorization token, can also be set by environment variable SD_TOKEN'
+    flag [:t, :token]
+
+    desc 'URL to Smartdust Lab, can also be set by environment variable SD_URL'
+    flag [:u, :url]
+
+    pre do |global_options, command, options, args|
+
+      global_options[:url] = ENV['SD_URL'] if global_options[:url].nil?
+      global_options[:token] = ENV['SD_TOKEN'] if global_options[:token].nil?
+
+      help_now!('Smartdust Lab url is required') if global_options[:url].nil?
+      help_now!('Authorization token is required') if global_options[:token].nil?
+
+      Log::verbose(global_options[:verbose])
+
+      DI.init(global_options)
+
+      help_now!('Valid Smartdust Lab url is required, e.g. https://public.smartdust.me') if !DI[:uri_validator].validate(global_options[:url])
+      true
+    end
+
+    desc 'Search for a device available in Smartdust Lab and attach it to local adb server'
+    command :connect do |c|
+      c.desc 'Connect to all available devices'
+      c.switch [:all]
+      c.desc 'Required quantity of devices'
+      c.flag [:n]
+      c.desc 'Minimal quantity of devices, n/2 by default'
+      c.flag [:min]
+      c.desc 'Filter key:value for devices'
+      c.flag [:f, :filter]
+      c.desc 'Force filter check for connected devices'
+      c.switch [:forcefilter, :ff]
+      c.desc 'Check selected health parameters, could be any of the: battery,temperature,network,vpn,wifi'
+      c.flag [:health]
+      c.desc 'Maximum session duration in seconds, 10800 (3h) by default'
+      c.flag [:session]
+      c.desc 'Maximum time to connect minimal quantity of devices in seconds, 120 (2m) by default'
+      c.flag [:starttime]
+      c.desc 'Do not start daemon'
+      c.switch [:nodaemon]
+
+      c.action do |_, options, _|
+        unless DI[:start_debug_session_interactor].execute(options)
+          raise GLI::CustomExit.new('Connect failed', 1)
+        end
+      end
+    end
+
+    desc 'Show available keys for filtering'
+    command :keys do |c|
+      c.action {puts DI[:get_keys_interactor].execute}
+    end
+
+    desc 'Show known values for the filtering key'
+    command :values do |c|
+      c.action do |_, _, args|
+        exit_now!('Please specify one key') if args.empty?
+
+        puts DI[:get_values_interactor].execute(args.first)
+      end
+    end
+
+    desc 'Disconnect device(s) from local adb server and remove device(s) from user devices in Smartdust Lab'
+    command :disconnect do |c|
+      c.desc '(optional) ADB connection url of the device'
+      c.switch [:all]
+
+      c.action do |_, options, args|
+        if args.empty? && options[:all] == true
+          DI[:stop_all_debug_sessions_interactor].execute
+        elsif !args.empty? && options[:all] == false
+          DI[:stop_debug_session_interactor].execute(args.first)
+        elsif exit_now!('Please specify one device or mode --all')
+        end
+      end
+    end
+
+    desc 'Frees all devices that are assigned to current user in Smartdust Lab. Doesn\'t modify local adb'
+    command :clean do |c|
+      c.action {DI[:remove_all_user_devices_interactor].execute}
+    end
+
+    desc 'Add adb public key into Smartdust Lab'
+    command :trustme do |c|
+      c.desc 'Location of adb public key'
+      c.flag [:k, :adb_public_key_location]
+      c.default_value '~/.android/adbkey.pub'
+
+      c.action do |_, options, _|
+        filename = File.expand_path(options[:adb_public_key_location])
+        exit_now!("File does not exist: '#{options[:adb_public_key_location]}'") unless File.exist? filename
+        DI[:add_adb_public_key_interactor].execute(options[:adb_public_key_location])
+      end
+    end
+
+    exit run(ARGV)
+  end
+end
+

data/lib/stf.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'stf/view/cli'
+
+module Stf
+  include Stf::CLI
+end