optimus-runner 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: '049b2ebd68e2b3b5f6f65b7a3220d555eda5c4a3'
+  data.tar.gz: 0d535587105a8096123b39b2cba2c108dedde3ec
+SHA512:
+  metadata.gz: 02dd05ef2756ccb6d15c3a3989d20fa77c5516862b3b9cb071907d83a047db12f7faf44eb9d80db8235acefa14b5ca9c975575a50c84f0e5b226f00ebb231f96
+  data.tar.gz: dc68db6814859e4065699d0f8d1e0084ce0c8e74e3638c27a1b31ecf5ce87c92d06861cc919cb8cd3336f48f50ba4cbb0f1bb664158eb8deaa69624d31401c48

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.idea/
+Gemfile.lock
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.5.1
+before_install: gem install bundler -v 1.16.1

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in optimus-runner.gemspec
+gemspec

data/README.md

@@ -0,0 +1,35 @@
+# Gandalf
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/gandalf`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'optimus-runner'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install gandalf
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/gandalf.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "optimus-runner"
+
+# 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(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/optimus-runner

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+require 'daemons'
+
+`mkdir -p ~/optimus_runner/logs`
+options = {
+    :app_name           => "optimus-runner",
+    :dir_mode           => :normal,
+    :dir                => "#{File.expand_path('~')}/or/pids",
+    :multiple           => true,
+    :log_output         => true,
+    :pid_delimiter      => '.n',
+    :backtrace          => true,
+    :monitor            => true,
+    :log_dir            => "#{File.expand_path('~')}/or/logs",
+    :logfilename        => 'optimus-runner.log'
+}
+Daemons.run('optimus_runner_manager', options)
+

data/exe/optimus_runner_manager

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+require 'optimus-runner/server/optimus_runner_sm'
+require 'rufus/scheduler'
+require 'logger'
+
+
+optimus_runner_sm = OptimusRunnerSM.new
+scheduler = Rufus::Scheduler.new
+logger = Logger.new(STDOUT)
+logger.level = Logger::WARN
+logger.info "Starting Optimus runner..."
+
+scheduler.interval '5s', :first_in => 0.1 do
+    logger.info "Is Optimus runner idle? #{optimus_runner_sm.idle?}"
+    optimus_runner_sm.create if optimus_runner_sm.idle?
+    optimus_runner_sm.add if optimus_runner_sm.new_device_added?
+    optimus_runner_sm.remove if optimus_runner_sm.device_removed?
+    optimus_runner_sm.restart if optimus_runner_sm.session_terminated?
+end
+scheduler.join

data/lib/optimus-runner.rb

@@ -0,0 +1,32 @@
+require 'optimus-runner/version'
+require 'daemons'
+require 'optimus-runner/server/appium_server_manager'
+
+
+module Gandalf
+  class Optimus_Runner
+    attr_reader :options, :optimus_runner_sm, :scheduler
+
+    def initialize(options)
+      @options = options
+      @optimus_runner_sm = OptimusRunnerSM.new
+      @scheduler = Rufus::Scheduler.new
+      logger = Logger.new(STDOUT)
+      logger.level = Logger::WARN
+      logger.info "Starting Optimus runner..."
+    end
+
+
+    def run!
+      @scheduler.interval '5s', :first_in => 0.1 do
+        logger.info "Is Optimus runner idle? #{@optimus_runner_sm.idle?}"
+        @optimus_runner_sm.create if @optimus_runner_sm.idle?
+        @optimus_runner_sm.add if @optimus_runner_sm.new_device_added?
+        @optimus_runner_sm.remove if @optimus_runner_sm.device_removed?
+        @optimus_runner_sm.restart if @optimus_runner_sm.session_terminated?
+      end
+      @scheduler.join
+    end
+  end
+end
+

data/lib/optimus-runner/AppiumLocalService.rb

@@ -0,0 +1,80 @@
+require 'random-port'
+require 'socket'
+require 'open3'
+
+class AppiumLocalService
+  @@sessions_with_pid = []
+
+  def get_session_details
+    @@sessions_with_pid
+  end
+
+  def launch_appium_sessions(device_details)
+    sessions = []
+    p "Device details in Launch Appium Sessions = #{device_details}"
+    p "Device details in Launch Appium Sessions = #{device_details.length}"
+    device_details.each do |device_detail|
+      session_id =  create_session device_detail
+      session_info = {}
+      session_info["sessionUrl"] = session_id
+      session_info["sessionCapabilities"] = device_detail
+      sessions.push(session_info)
+    end
+    sessions
+  end
+
+  def launch_appium_session(device_detail)
+    session_detail = create_session device_detail
+    p session_detail
+    return session_detail
+  end
+
+  def create_session(device_detail)
+    RandomPort::Pool::SINGLETON.acquire do |port|
+      @port = port
+    end
+    puts @port
+    begin
+      Timeout.timeout(5) do
+        @pid = spawn(get_cmd(device_detail))
+        Process.wait @pid
+      end
+    end
+  rescue Timeout::Error
+    p @pid
+    @ipaddress = Socket.ip_address_list[4].ip_address
+    session_id = get_session_id
+    add_session_details session_id
+  return session_id
+  end
+
+
+  private
+
+  def get_cmd(device_detail)
+    case device_detail["platform"]
+    when "ANDROID"
+      return "appium -p #{@port} --bootstrap-port #{get_random_port}"
+    when "IOS"
+      return "appium -p #{@port} --webdriveragent-port #{get_random_port}"
+    end
+  end
+
+  def get_random_port
+   port =  RandomPort::Pool.new.acquire
+   return port
+  end
+  def get_session_id
+    "http://#{@ipaddress}:#{@port}/wd/hub"
+  end
+
+  def add_session_details(session_id)
+    session_details = {}
+    session_details["session_id"] = session_id
+    session_details["session_pid"] = @pid
+    @@sessions_with_pid.push session_details
+  end
+
+
+
+end

data/lib/optimus-runner/DeviceDetails.rb

@@ -0,0 +1,56 @@
+require 'HTTParty'
+
+class DeviceDetails
+
+  def get_device_details
+    device_names = self.process_android_devices
+    android_device_details = find_android_devices(device_names)
+    ios_device_details = process_ios_devices
+    p "IOS Devices = #{ios_device_details}"
+    p "IOS Devices = #{ios_device_details.length}"
+    device_details = android_device_details+ios_device_details
+    device_details
+  end
+
+  def process_android_devices
+    devices = `adb devices`
+    query = { deviceLog: devices }.to_json
+    puts query
+    headers = {
+         'Content-Type': "Application/json"
+    }
+    response = HTTParty.post('http://localhost:9099/processDevices', body: query, headers: headers)
+  end
+
+  def process_ios_devices
+    devices = `instruments -s devices | grep 'iPhone'`
+    p devices
+    body = { deviceLog: devices }.to_json
+    headers = {
+        'Content-Type': "Application/json"
+    }
+    response = HTTParty.post('http://localhost:9099/processIosDevices', body: body, headers: headers)
+    p response
+    res  = JSON.parse(response.to_s)
+    return res
+  end
+
+  def find_android_devices(device_names)
+    res  = JSON.parse(device_names.to_s)
+    device_details = []
+    res.each do |a|
+      device_model =  `adb -s #{a['udid']} shell getprop ro.product.model`
+      device_os_version =  `adb -s #{a['udid']} shell getprop ro.build.version.release`
+      a['deviceName'] = device_model.to_s.rstrip
+      a['platformVersion'] = device_os_version.to_s.rstrip
+      a["platform"] = "ANDROID"
+      device_details.push(a)
+    end
+    device_details
+  end
+
+end
+
+div_details = DeviceDetails.new
+details = div_details.get_device_details
+p details

data/lib/optimus-runner/SessionInfoBuilder.rb

@@ -0,0 +1,19 @@
+class SessionInfo
+
+  def create_session_info
+    session_info_list = []
+    (0..@session.length - 1).each {|session|
+      session_info = {}
+      session_info["sessionUrl"] = @session[session]
+      session_info["sessionCapabilities"] = @device_details[session]
+      session_info_list.push session_info
+    }
+    session_info_list
+  end
+
+  def initialize(session, device_details)
+    @session = session
+    @device_details = device_details
+  end
+
+end

data/lib/optimus-runner/clients/AkiraClient.rb

@@ -0,0 +1,50 @@
+require 'HTTParty'
+
+class AkriaClient
+  attr_accessor :base_uri
+
+  def initialize
+    @base_uri = "http://localhost:6889"
+  end
+
+  def save_sessions(session_info)
+    uri = "#{@base_uri}/sessions"
+    puts uri
+    HTTParty.post(uri , body: session_info.to_json, headers: get_default_headers)
+  end
+
+  def save_session(session_info)
+    uri = "#{@base_uri}/session"
+    puts uri
+    HTTParty.post(uri , body: session_info.to_json, headers: get_default_headers)
+  end
+
+  def remove_session(session_url)
+    uri = "#{@base_uri}/removeSession"
+    query_params = {
+        'sessionUrl':session_url
+    }
+    HTTParty.put(uri, query: query_params, headers: get_default_headers)
+  end
+
+  def get_session_info(session_url)
+    uri = "#{@base_uri}/sessionInfo"
+    puts uri
+    query_params = {
+        'sessionUrl':session_url
+    }
+    response = HTTParty.get(uri, query: query_params, headers: get_default_headers)
+    session_info  = JSON.parse(response.to_s)
+    return session_info
+  end
+
+
+  def get_default_headers
+    headers = {
+        'Content-Type': "Application/json"
+    }
+    return  headers
+  end
+
+
+end

data/lib/optimus-runner/commands/ShellCommands.rb

@@ -0,0 +1,6 @@
+
+class ShellCommands
+  def kill_process(pid)
+    spawn("kill #{pid}")
+  end
+end

data/lib/optimus-runner/server/appium_server_manager.rb

@@ -0,0 +1,19 @@
+require 'optimus-runner/server/optimus_runner_sm'
+require 'rufus/scheduler'
+require 'logger'
+
+
+optimus_runner_sm = OptimusRunnerSM.new
+scheduler = Rufus::Scheduler.new
+logger = Logger.new(STDOUT)
+logger.level = Logger::WARN
+logger.info "Starting Optimus runner..."
+
+scheduler.interval '5s', :first_in => 0.1 do
+    logger.info "Is Optimus runner idle? #{optimus_runner_sm.idle?}"
+    optimus_runner_sm.create if optimus_runner_sm.idle?
+    optimus_runner_sm.add if optimus_runner_sm.new_device_added?
+    optimus_runner_sm.remove if optimus_runner_sm.device_removed?
+    optimus_runner_sm.restart if optimus_runner_sm.session_terminated?
+end
+scheduler.join

data/lib/optimus-runner/server/array_manipulations.rb

@@ -0,0 +1,10 @@
+
+
+class ArrayManipulations
+
+  init_arr = [{"udid"=>"ae544f54", "deviceType"=>"DEVICE", "deviceName"=>"SM-J510FN", "platformVersion"=>"7.1.1"}, {"udid"=>"HGEPX64G", "deviceType"=>"DEVICE", "deviceName"=>"Lenovo A7700", "platformVersion"=>"6.0" }]
+  later_arr = [{"udid"=>"ae544f54", "deviceType"=>"DEVICE", "deviceName"=>"SM-J510FN", "platformVersion"=>"7.1.1"}, {"udid"=>"HGEPX64G", "deviceType"=>"DEVICE", "deviceName"=>"Lenovo A7700", "platformVersion"=>"6.0" }]
+
+  diff_arr =  init_arr-later_arr
+  diff_arr1 = later_arr-init_arr
+end

data/lib/optimus-runner/server/optimus_runner_sm.rb

@@ -0,0 +1,207 @@
+require 'aasm'
+require 'json'
+require 'pp'
+require 'HTTParty'
+require 'optimus-runner/DeviceDetails'
+require 'json'
+require 'optimus-runner/AppiumLocalService'
+require 'optimus-runner/SessionInfoBuilder'
+require 'optimus-runner/clients/AkiraClient'
+require 'optimus-runner/clients/AkiraClient'
+require 'logger'
+require 'optimus-runner/commands/ShellCommands'
+
+class OptimusRunnerSM
+  include AASM
+  attr_accessor :session_info
+
+  def initialize
+    @logger = Logger.new(STDOUT)
+    @initial_device_set = []
+    @device_details = []
+    set_restart_session
+    set_is_session_added
+    set_is_session_removed
+    set_is_session_restarted
+  end
+
+  aasm do
+    state :idle, :initial => true, :before_enter => :gather_initial_device_set
+    state :created, :added, :removed, :restarted
+
+    event :create, :before => [:create_sessions, :gather_initial_device_set] do
+      transitions :from => :idle, :to => :created, :guard => :devices_available?
+      transitions :from => :idle, :to => :idle
+    end
+
+    event :add, :before => :add_sessions do
+      transitions :from => [:created, :added, :removed, :restarted], :to => :added, :guard => :session_added?
+      transitions :from => [:created, :added, :removed, :restarted], :to => :created, :guard => :devices_available?
+      transitions :from => [:created, :added, :removed, :restarted], :to => :idle
+    end
+
+    event :remove, :before => :remove_sessions do
+      transitions :from => [:created, :added, :removed, :restarted], :to => :removed, :guard => :session_removed?
+      transitions :from => [:created, :added, :removed, :restarted], :to => :created, :guard => :devices_available?
+      transitions :from => [:created, :added, :removed, :restarted], :to => :idle
+    end
+
+    event :restart, :before => :restart_sessions do
+      transitions :from => [:created, :added, :removed, :restarted], :to => :restarted, :guard => :session_restarted?
+      transitions :from => [:created, :added, :removed, :restarted], :to => :created, :guard => :devices_available?
+      transitions :from => [:created, :added, :removed, :restarted], :to => :idle
+    end
+  end
+
+  def devices_available?
+    gather_devices
+    @device_details.length > 0
+  end
+
+  def gather_initial_device_set
+    details = DeviceDetails.new
+    @initial_device_set = details.get_device_details
+    @logger.info "Initial Device Set #{@initial_device_set}"
+  end
+
+  def session_added?
+    @session_added
+  end
+
+  def session_removed?
+    @session_removed
+  end
+
+  def session_restarted?
+    @session_restarted
+  end
+
+  def gather_devices
+    details = DeviceDetails.new
+    @device_details = details.get_device_details
+    @logger.info "Current devices connected are #{@device_details}"
+  end
+
+  def create_sessions
+    return unless devices_available?
+    @logger.info "Device details found are #{@device_details}"
+    sessions = AppiumLocalService.new.launch_appium_sessions(@device_details)
+    puts sessions
+    @session_info = sessions
+    AkriaClient.new.save_sessions(@session_info)
+  end
+
+  def create_new_session(device_details)
+    @logger.info "Found new device added #{device_details}"
+    session_info = AppiumLocalService.new.launch_appium_sessions(device_details)
+    # puts session
+    # session_info = SessionInfo.new(session,device_details).create_session_info
+    AkriaClient.new.save_sessions(session_info)
+    @session_info.push session_info[0]
+    p @session_info
+  end
+
+  def add_sessions
+    return unless devices_available?
+    if new_device_added?
+      create_new_session get_added_devices
+      @initial_device_set = @device_details
+      @session_added = true
+    end
+  end
+
+  def remove_sessions
+    return unless devices_available?
+    if device_removed?
+      get_removed_devices.each do |removed_device|
+        p removed_device
+        session_info = @session_info.detect {|info| info["sessionCapabilities"]==removed_device}
+        p session_info
+        AkriaClient.new.remove_session session_info["sessionUrl"]
+        session_details = AppiumLocalService.new.get_session_details
+        session_detail = session_details.detect {|session_detail| session_detail["session_id"]==session_info["sessionUrl"]}
+        puts "Removed session details #{session_details}"
+        ShellCommands.new.kill_process session_detail["session_pid"]
+        @session_info.delete_if{ |session_inf| session_inf["sessionUrl"] == session_info["sessionUrl"]}
+        @session_removed= true
+        @initial_device_set = @device_details
+      end
+    end
+
+
+  end
+
+  def session_terminated?
+    return false unless devices_available?
+    akira = AkriaClient.new
+    @session_info.each do |session|
+      p "Session #{session}"
+      @logger.info "Checking if the session #{session["sessionUrl"]} is terminated"
+      session_info =  akira.get_session_info session["sessionUrl"]
+      session_state = session_info["sessionState"]
+      @is_session_terminated = session_state.eql? "TERMINATED"
+      @logger.info "Is session #{session["sessionUrl"]} terminated? #{@is_session_terminated}"
+      @restart_session = session_info if @is_session_terminated
+      @logger.info "Session Details to restart #{@restart_session}"
+      break unless @restart_session.empty?
+    end
+    return @is_session_terminated
+  end
+
+  def restart_sessions
+    session = AppiumLocalService.new.launch_appium_session @restart_session["sessionCapabilities"]
+    @logger.info "Restarting session #{@restart_session}"
+    @logger.info "Session details are #{@session_info}"
+    @session_info.delete_if{ |session_inf| session_inf["sessionUrl"] == @restart_session["sessionUrl"]}
+    @logger.info "Session details are #{@session_info}"
+    @restart_session["sessionUrl"] = session
+    @session_info.push(@restart_session)
+    @logger.info "Session details are #{@session_info}"
+    AkriaClient.new.save_session @restart_session
+    set_restart_session
+    @session_restarted = true
+  end
+
+  def new_device_added?
+    added_device = get_added_devices
+    p "Is new devices added #{added_device.length>0}"
+    p "Added devices length #{added_device.length}"
+    p "Added devices #{added_device}"
+    return added_device.length>0
+  end
+
+  def device_removed?
+    removed_device = get_removed_devices
+    @logger.info "Device #{removed_device} is removed"
+    return removed_device.length>0
+  end
+
+  def set_is_session_restarted
+    @session_restarted = false
+  end
+
+  def set_is_session_removed
+    @session_removed = false
+  end
+
+  def set_is_session_added
+    @session_added = false
+  end
+
+  def set_restart_session
+    @restart_session = {}
+  end
+
+  private
+
+  def get_added_devices
+    added_device = @device_details - @initial_device_set
+    return added_device
+  end
+
+  def get_removed_devices
+    removed_device = @initial_device_set - @device_details
+    return removed_device
+  end
+end
+