roku_builder 4.25.5 → 4.26.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 852ae89e38456c17e455675a4901b37914f6109a47202137efecef4e4cb68309
-  data.tar.gz: 95f9cd039b170352a7f7868ec9ff52663e6e22add7dd3bf883a96112ea9680d4
+  metadata.gz: 26fe47ba62ff48e37fe3bd5dda06ff687b79c30dc67bd7dd216747363cf6efbd
+  data.tar.gz: cc5480949806270e823d1a177219a48f541abbdde571c949022d9ae16a3cf11a
 SHA512:
-  metadata.gz: 14157cf2cfb8268d30f9acee98af461e7b0c500a57bb6ec2e95254e1b7c3859087eb5ed0fd2e57b9ed660aa1c825f1d8623250a6a409c8062a2d77ee8d74f156
-  data.tar.gz: 6e50b5767da2018fd30550766fb681167a1ded341d85b810eae2ba95517080c16df74f46aad1bc5ec37658e3cb35b94e1c7659b1e36292fd1daae7aef17d4415
+  metadata.gz: 7dd09cf68f00832afb02e2797643d6babcb81c6cb943523c883b77b0f2d361bb03fe642c8fe54f685e9565dea175d23974fd1fa9f4ccbbb79be53e559471eb5a
+  data.tar.gz: b847c41f764a41db7421c0cba806e7ed264695ec0283f8af28a0a8dad1fdeda731c66c6757bb67faa5ef74e19a45488c33c61f97e3df837d5b9eb1903be12fe3

data/intergration/roku_builder/test_helper.rb

@@ -15,7 +15,7 @@ require "minitest/autorun"
 require "minitest/utils"
 require "securerandom"
 
-ROKU_IP = "192.168.1.127"
+ROKU_IP = "192.168.11.114"
 
 module Minitest
   module Assertions
@@ -114,8 +114,7 @@ module Helpers
       default: :project1,
       project1: {
       directory: root_dir,
-      folders: ["resources","source","components"],
-      files: ["manifest","file.tmp"],
+      source_files: ["images","source","components", "manifest","file.tmp"],
       app_name: "App Name",
       stage_method: :script,
       stages:{

data/intergration/roku_builder/test_profiler.rb

@@ -48,7 +48,7 @@ module RokuBuilder
       `#{roku} --sideload --working`
       assert_log @uuid
       output = `#{roku} --profile images`
-      assert_match(/Available memory/, output)
+      assert_match(/Available texture memory/, output)
     end
     def test_profile_textures
       `#{roku} --sideload --working`

data/lib/roku_builder/config_parser.rb

@@ -21,7 +21,7 @@ module RokuBuilder
 
     def parse_config
       process_in_argument
-      setup_device
+      setup_devices
       setup_project
       setup_in_out_file
       setup_project_config
@@ -35,10 +35,9 @@ module RokuBuilder
       @options[:in] = File.expand_path(@options[:in]) if @options[:in]
     end
 
-    def setup_device
-      @options[:device] = @config[:devices][:default] unless @options[:device]
-      @parsed[:device_config] = @config[:devices][@options[:device].to_sym]
-      raise ArgumentError, "Unknown device: #{@options[:device]}" unless @parsed[:device_config]
+    def setup_devices
+      @parsed[:device_default] = @config[:devices][:default]
+      @parsed[:devices] = @config[:devices].select{|key, value| :default != key}
     end
 
     def setup_project

data/lib/roku_builder/device_manager.rb

@@ -0,0 +1,100 @@
+# ********** Copyright Viacom, Inc. Apache 2.0 **********
+
+module RokuBuilder
+
+  class DeviceManager
+
+    def initialize(options:, config:)
+      @config = config
+      @options = options
+      @timeout_duration = 3600
+    end
+
+    def reserve_device(no_lock: false)
+      message = "No Devices Found"
+      if @options[:device]
+        device = Device.new(@options[:device], @config.raw[:devices][@options[:device].to_sym])
+        return device if device_available!(device: device, no_lock: no_lock)
+        message = "Device #{@options[:device]} not found"
+      else
+        begin
+          Timeout::timeout(@timeout_duration) do
+            loop do
+              device = reserve_any(no_lock: no_lock)
+              if device
+                Logger.instance.info "Using Device: #{device.to_s}"
+                return device
+              end
+              break unless @options[:device_blocking]
+            end
+          end
+        rescue Timeout::Error
+        end
+      end
+      raise DeviceError, message
+    end
+
+    def release_device(device)
+      lock = lock_file(device)
+      File.delete(lock) if File.exist?(lock)
+    end
+
+    private
+
+    def reserve_any(no_lock: false)
+      default = @config.device_default
+      all_devices = @config.devices.keys.reject{|key, value| default == key}
+      all_devices.unshift(default)
+      all_devices.each do |device_name|
+        device = Device.new(device_name, @config.devices[device_name])
+        if device_available!(device: device, no_lock: no_lock)
+          return device
+        end
+      end
+      nil
+    end
+
+    def device_available!(device:, no_lock: false)
+      return false unless device_ping?(device)
+      return true if no_lock
+      file = lock_file(device)
+      lock = file.flock(File::LOCK_EX|File::LOCK_NB)
+      return false if lock == false
+      text = file.readlines
+      return false if text.count > 0
+      file.write($$)
+      file.pos = 0
+      text = file.readlines
+      if text[0] != $$.to_s
+        file.flock(File::LOCK_UN)
+        return false
+      end
+      true
+    end
+
+    def device_ping?(device)
+      ping = Net::Ping::External.new
+      ping.ping? device.ip, 1, 0.2, 1
+    end
+
+    def lock_file(device)
+      File.open(File.join(Dir.tmpdir, device.name), File::RDWR | File::APPEND | File::CREAT | File::BINARY | File::SHARE_DELETE) #"a+")
+    end
+
+  end
+
+  class Device
+    attr_accessor :name, :ip, :user, :password
+
+    def initialize(name, device_config)
+      @name = name.to_s
+      @ip = device_config[:ip]
+      @user = device_config[:user]
+      @password = device_config[:password]
+    end
+
+    def to_s
+      "#{name}:#{ip}"
+    end
+  end
+end

data/lib/roku_builder/plugins/core.rb

@@ -67,7 +67,9 @@ module RokuBuilder
       end
       parser.on("-D", "--device ID", "Use a different device corresponding to the given ID") do |d|
         options[:device] = d
-        options[:device_given] = true
+      end
+      parser.on("--device-blocking", "Block and wait for a device if none is ready. Does not work with --device") do
+        options[:device_blocking] = true
       end
       parser.on("-V", "--verbose", "Print Info message") do
         options[:verbose] = true

data/lib/roku_builder/plugins/inspector.rb

@@ -33,13 +33,15 @@ module RokuBuilder
       pkg = pkg+".pkg" unless pkg.end_with?(".pkg")
       # upload new key with password
       path = "/plugin_inspect"
-      conn = multipart_connection
-      payload =  {
-        mysubmit: "Inspect",
-        passwd: options[:password],
-        archive: Faraday::UploadIO.new(pkg, 'application/octet-stream')
-      }
-      response = conn.post path, payload
+      response = nil
+      multipart_connection do |conn|
+        payload =  {
+          mysubmit: "Inspect",
+          passwd: options[:password],
+          archive: Faraday::UploadIO.new(pkg, 'application/octet-stream')
+        }
+        response = conn.post path, payload
+      end
 
       app_name = /App Name:\s*<\/td>\s*<td>\s*<font[^>]*>([^<]*)<\/font>\s*<\/td>/.match(response.body)
       dev_id = nil
@@ -75,30 +77,38 @@ module RokuBuilder
     # Capture a screencapture for the currently sideloaded app
     # @return [Boolean] Success
     def screencapture(options:)
-      out = @config.out
-      payload =  {
-        mysubmit: "Screenshot",
-        passwd: @dev_password,
-        archive: Faraday::UploadIO.new(File::NULL, 'application/octet-stream')
-      }
-      response = multipart_connection.post "/plugin_inspect", payload
+      get_device do |device|
+        out = @config.out
+        payload =  {
+          mysubmit: "Screenshot",
+          passwd: @dev_password,
+          archive: Faraday::UploadIO.new(File::NULL, 'application/octet-stream')
+        }
+        response = nil
+        multipart_connection(device: device) do |conn|
+          response = conn.post "/plugin_inspect", payload
+        end
 
-      path = /<img src="([^"]*)">/.match(response.body)
-      raise ExecutionError, "Failed to capture screen" unless path
-      path = path[1]
+        path = /<img src="([^"]*)">/.match(response.body)
+        raise ExecutionError, "Failed to capture screen" unless path
+        path = path[1]
 
-      unless out[:file]
-        out[:file] = /time=([^"]*)">/.match(response.body)
-        out_ext = /dev.([^"]*)\?/.match(response.body)
-        out[:file] = "dev_#{out[:file][1]}.#{out_ext[1]}" if out[:file]
-      end
+        unless out[:file]
+          out[:file] = /time=([^"]*)">/.match(response.body)
+          out_ext = /dev.([^"]*)\?/.match(response.body)
+          out[:file] = "dev_#{out[:file][1]}.#{out_ext[1]}" if out[:file]
+        end
 
-      response = simple_connection.get path
+        response = nil
+        simple_connection(device: device) do |conn|
+          response = conn.get path
+        end
 
-      File.open(File.join(out[:folder], out[:file]), "wb") do |io|
-        io.write(response.body)
+        File.open(File.join(out[:folder], out[:file]), "wb") do |io|
+          io.write(response.body)
+        end
+        @logger.info "Screen captured to #{File.join(out[:folder], out[:file])}"
       end
-      @logger.info "Screen captured to #{File.join(out[:folder], out[:file])}"
     end
   end
   RokuBuilder.register_plugin(Inspector)

data/lib/roku_builder/plugins/line_inspector.rb

@@ -47,17 +47,38 @@ module RokuBuilder
             match  = nil
             start = 0
             loop do
+              stop = to_check.length-1
+              pass_match = nil
+              if line_inspector[:pass_if_match]
+                if line_inspector[:case_sensitive]
+                  pass_match = /#{line_inspector[:pass_test_regexp]}/.match(to_check[start..stop])
+                else
+                  pass_match = /#{line_inspector[:pass_test_regexp]}/i.match(to_check[start..stop])
+                end
+                break unless pass_match
+                stop = to_check.index("\n", start)
+                stop ||= to_check.length-1
+              end
               if line_inspector[:case_sensitive]
-                match = /#{line_inspector[:regex]}/.match(to_check, start)
+                match = /#{line_inspector[:regex]}/.match(to_check[start..stop])
               else
-                match = /#{line_inspector[:regex]}/i.match(to_check, start)
+                match = /#{line_inspector[:regex]}/i.match(to_check[start..stop])
               end
-              if match
-                start = match.end(0)
-                line_number = to_check[0..match.begin(0)].split("\n", -1).count - 1
+              if (not line_inspector[:pass_if_match] and match) or (line_inspector[:pass_if_match] and not match)
+                error_match = match
+                if match
+                  start = match.end(0)
+                  line_number = to_check[0..match.begin(0)].split("\n", -1).count - 1
+                else
+                  error_match = pass_match
+                  line_number = to_check[0..start].split("\n", -1).count - 1
+                  start = stop
+                end
                 unless lines_to_ignore.include?(line_number)
-                  add_warning(inspector: line_inspector, file: file_path, line: line_number, match: match)
+                  add_warning(inspector: line_inspector, file: file_path, line: line_number, match: error_match)
                 end
+              elsif line_inspector[:pass_if_match]
+                start = stop +1
               else
                 break
               end

data/lib/roku_builder/plugins/linker.rb

@@ -36,14 +36,16 @@ module RokuBuilder
     end
 
     # Deeplink to an app
-    def deeplink(options:)
-      if options.has_source?
-        Loader.new(config: @config).sideload(options: options)
+    def deeplink(options:, device: nil)
+      get_device(device: device) do |device|
+        if options.has_source?
+          Loader.new(config: @config).sideload(options: options, device: device)
+        end
+        app_id = options[:app_id]
+        app_id ||= "dev"
+        path = "/launch/#{app_id}"
+        send_options(path: path, options: options[:deeplink], device: device)
       end
-      app_id = options[:app_id]
-      app_id ||= "dev"
-      path = "/launch/#{app_id}"
-      send_options(path: path, options: options[:deeplink])
     end
 
     def input(options:)
@@ -54,8 +56,10 @@ module RokuBuilder
     # @param logger [Logger] System Logger
     def applist(options:)
       path = "/query/apps"
-      conn = multipart_connection(port: 8060)
-      response = conn.get path
+      response = nil
+      multipart_connection(port: 8060) do |conn|
+        response = conn.get path
+      end
 
       if response.success?
         regexp = /id="([^"]*)"\stype="([^"]*)"\sversion="([^"]*)">([^<]*)</
@@ -70,22 +74,25 @@ module RokuBuilder
 
     private
 
-    def send_options(path:, options:)
+    def send_options(path:, options:, device: nil)
       payload = RokuBuilder.options_parse(options: options)
+      get_device(device: device) do |device|
+        unless payload.keys.count > 0
+          @logger.warn "No options sent to launched app"
+        else
+          payload = parameterize(payload)
+          path = "#{path}?#{payload}"
+            @logger.info "Deeplink:"
+          @logger.info payload
+          @logger.info "CURL:"
+          @logger.info "curl -d '' 'http://#{device.ip}:8060#{path}'"
+        end
 
-      unless payload.keys.count > 0
-        @logger.warn "No options sent to launched app"
-      else
-        payload = parameterize(payload)
-        path = "#{path}?#{payload}"
-        @logger.info "Deeplink:"
-        @logger.info payload
-        @logger.info "CURL:"
-        @logger.info "curl -d '' '#{@url}:8060#{path}'"
+        multipart_connection(port: 8060, device: device) do |conn|
+          response = conn.post path
+          @logger.fatal("Failed Deeplinking") unless response.success?
+        end
       end
-
-      response = multipart_connection(port: 8060).post path
-      @logger.fatal("Failed Deeplinking") unless response.success?
     end
 
     # Parameterize options to be sent to the app

data/lib/roku_builder/plugins/loader.rb

@@ -50,16 +50,20 @@ module RokuBuilder
     end
 
     # Sideload an app onto a roku device
-    def sideload(options:)
+    def sideload(options:, device: nil)
       did_build = false
       unless options[:in]
         did_build = true
         build(options: options)
       end
       keep_build_file = is_build_command(options) and options[:out]
-      upload(options)
+      upload(options: options, device: device)
       # Cleanup
-      File.delete(file_path(:in)) if did_build and not keep_build_file
+      begin
+        File.delete(file_path(:in)) if did_build and not keep_build_file
+      rescue Errno::EACCES
+        @logger.warn "Unable to delete: " + file_path(:in)
+      end
     end
 
 
@@ -76,18 +80,30 @@ module RokuBuilder
 
     # Remove the currently sideloaded app
     def delete(options:, ignoreFailure: false)
-      payload =  {mysubmit: "Delete", archive: ""}
-      response  = multipart_connection.post "/plugin_install", payload
+      payload =  {
+        mysubmit: make_param("Delete"),
+        archive: make_param("", "application/octet-stream")
+      }
+      response = nil
+      multipart_connection do |conn|
+        response = conn.post "/plugin_install", payload
+      end
       unless response.status == 200 and response.body =~ /Delete Succeeded/ or ignoreFailure
         raise ExecutionError, "Failed Unloading"
       end
     end
 
     # Convert sideloaded app to squashfs
-    def squash(options:, ignoreFailure: false)
-      payload =  {mysubmit: "Convert to squashfs", archive: ""}
-      response  = multipart_connection.post "/plugin_install", payload
-      unless response.status == 200 and response.body =~ /Conversion succeeded/ or ignoreFailure
+    def squash(options:, device: nil, ignoreFailure: false)
+      payload =  {
+        mysubmit: "Convert to squashfs",
+        archive: make_param("", "application/octet-stream")
+      }
+      response = nil
+      multipart_connection(device: device) do |conn|
+        response = conn.post "/plugin_install", payload
+      end
+      unless response.status == 200 and response.body =~ /squashfs file in internal memory/ or ignoreFailure
         raise ExecutionError, "Failed Converting to Squashfs"
       end
     end
@@ -104,16 +120,19 @@ module RokuBuilder
       [:sideload, :build].include? options.command
     end
 
-    def upload(options)
+    def upload(options:,  device: nil)
       payload =  {
         mysubmit: "Replace",
         archive: Faraday::UploadIO.new(file_path(:in), 'application/zip'),
       }
       payload["remotedebug"] = "1" if options[:remoteDebug]
-      response = multipart_connection.post "/plugin_install", payload
+      response = nil
+      multipart_connection(device: device) do |conn|
+        response = conn.post "/plugin_install", payload
+      end
       @logger.debug("Status: #{response.status}, Body: #{response.body}")
       if response.status==200 and response.body=~/Identical to previous version/
-        @logger.warn("Sideload identival to previous version")
+        @logger.warn("Sideload identical to previous version")
       elsif not (response.status==200 and response.body=~/Install Success/)
         raise ExecutionError, "Failed Sideloading"
       end
@@ -141,11 +160,13 @@ module RokuBuilder
     end
 
     def build_zip(content)
-      path = file_path(:out)
-      File.delete(path) if File.exist?(path)
-      io = Zip::File.open(path, Zip::File::CREATE)
+      tmp_path = File.join(build_dir, SecureRandom.uuid+".zip")
+      io = Zip::File.open(tmp_path, Zip::File::CREATE)
       writeEntries(build_dir, content[:source_files], "", content[:excludes], io)
       io.close()
+      path = file_path(:out)
+      File.delete(path) if File.exist?(path)
+      FileUtils.mv(tmp_path, path)
     end
 
     # Recursively write directory contents to a zip archive

data/lib/roku_builder/plugins/monitor.rb

@@ -32,26 +32,28 @@ module RokuBuilder
 
     # Monitor a development log on the Roku device
     def monitor(options:)
-      type = options[:monitor].to_sym
-      telnet_config = { 'Host' => @roku_ip_address, 'Port' => @ports[type] }
-      waitfor_config = { 'Match' => /./, 'Timeout' => false }
-
-      thread = Thread.new(telnet_config, waitfor_config) {|telnet,waitfor|
-        @logger.info "Monitoring #{type} console(#{telnet['Port']}) on #{telnet['Host'] }"
-        connection = Net::Telnet.new(telnet)
-        Thread.current[:connection] = connection
-        all_text = ""
-        while true
-          connection.waitfor(waitfor) do |txt|
-            all_text = manage_text(all_text: all_text, txt: txt, regexp: options[:regexp])
+      get_device(no_lock: true) do |device|
+        type = options[:monitor].to_sym
+        telnet_config = { 'Host' => device.ip, 'Port' => @ports[type] }
+        waitfor_config = { 'Match' => /./, 'Timeout' => false }
+
+        thread = Thread.new(telnet_config, waitfor_config) {|telnet,waitfor|
+          @logger.info "Monitoring #{type} console(#{telnet['Port']}) on #{telnet['Host'] }"
+          connection = Net::Telnet.new(telnet)
+          Thread.current[:connection] = connection
+          all_text = ""
+          while true
+            connection.waitfor(waitfor) do |txt|
+              all_text = manage_text(all_text: all_text, txt: txt, regexp: options[:regexp])
+            end
           end
-        end
-      }
-      thread.abort_on_exception = true
+        }
+        thread.abort_on_exception = true
 
-      init_readline()
+        init_readline()
 
-      run_prompt(thread: thread)
+        run_prompt(thread: thread)
+      end
     end
 
     private

data/lib/roku_builder/plugins/navigator.rb

@@ -70,48 +70,54 @@ module RokuBuilder
     # Send a navigation command to the roku device
     # @param command [Symbol] The smbol of the command to send
     # @return [Boolean] Success
-    def nav(options:)
-      commands = options[:nav].split(/, */).map{|c| c.to_sym}
-      commands.each do |command|
-        unless @commands.has_key?(command)
-          raise ExecutionError, "Unknown Navigation Command"
+    def nav(options:, device: nil)
+      get_device(device: device, no_lock: true) do |device|
+        commands = options[:nav].split(/, */).map{|c| c.to_sym}
+        commands.each do |command|
+          unless @commands.has_key?(command)
+            raise ExecutionError, "Unknown Navigation Command"
+          end
+          multipart_connection(port: 8060, device: device) do |conn|
+            path = "/keypress/#{@commands[command]}"
+            @logger.debug("Send Command: "+path)
+            response = conn.post path
+            raise ExecutionError, "Navigation Failed" unless response.success?
+          end
         end
-        conn = multipart_connection(port: 8060)
-        path = "/keypress/#{@commands[command]}"
-        @logger.debug("Send Command: "+path)
-        response = conn.post path
-        raise ExecutionError, "Navigation Failed" unless response.success?
       end
     end
 
     # Type text on the roku device
     # @param text [String] The text to type on the device
     # @return [Boolean] Success
-    def type(options:)
-      conn = multipart_connection(port: 8060)
-      options[:type].split(//).each do |c|
-        path = "/keypress/LIT_#{CGI::escape(c)}"
-        @logger.debug("Send Letter: "+path)
-        response = conn.post path
-        return false unless response.success?
+    def type(options:, device: nil)
+      multipart_connection(port: 8060, device: device, no_lock: true) do |conn|
+        options[:type].split(//).each do |c|
+          path = "/keypress/LIT_#{CGI::escape(c)}"
+          @logger.debug("Send Letter: "+path)
+          response = conn.post path
+          return false unless response.success?
+        end
+        return true
       end
-      return true
     end
 
     def navigate(options:)
-      running = true
-      @logger.info("Key Mappings:")
-      @mappings.each_value {|key|
-        @logger.info(sprintf("%13s -> %s", key[1], @commands[key[0].to_sym]))
-      }
-      @logger.info(sprintf("%13s -> %s", "Ctrl + c", "Exit"))
-      while running
-        char = read_char
-        @logger.debug("Char: #{char.inspect}")
-        if char == "\u0003"
-          running = false
-        else
-          Thread.new(char) {|character| handle_navigate_input(character)}
+      get_device(no_lock: true) do |device|
+        running = true
+        @logger.info("Key Mappings:")
+        @mappings.each_value {|key|
+          @logger.info(sprintf("%13s -> %s", key[1], @commands[key[0].to_sym]))
+        }
+        @logger.info(sprintf("%13s -> %s", "Ctrl + c", "Exit"))
+        while running
+          char = read_char
+          @logger.debug("Char: #{char.inspect}")
+          if char == "\u0003"
+            running = false
+          else
+            Thread.new(char, device) {|character,device| handle_navigate_input(character, device)}
+          end
         end
       end
     end
@@ -208,11 +214,11 @@ module RokuBuilder
       end
     end
 
-    def handle_navigate_input(char)
+    def handle_navigate_input(char, device)
       if @mappings[char.to_sym] != nil
-        nav(options: {nav: @mappings[char.to_sym][0]})
+        nav(options: {nav: @mappings[char.to_sym][0]}, device: device)
       elsif char.inspect.force_encoding("UTF-8").ascii_only?
-        type(options: {type: char})
+        type(options: {type: char}, device: device)
       end
     end