roku_builder 4.25.5 → 4.25.6

data/lib/roku_builder/plugins/packager.rb

@@ -36,19 +36,21 @@ module RokuBuilder
 
     def package(options:)
       check_options(options)
-      #sideload
-      loader = Loader.new(config: @config)
-      loader.sideload(options: options)
-      loader.squash(options: options) if @config.stage[:squash]
-      #rekey
-      key(options: options)
-      #package
-      sign_package(app_name_version: "", password: @config.key[:password], stage: options[:stage])
-      #inspect
-      if options[:inspect_package]
-        @config.in = @config.out
-        options[:password] = @config.key[:password]
-        Inspector.new(config: @config).inspect(options: options)
+      get_device do |device|
+        #sideload
+        loader = Loader.new(config: @config)
+        loader.sideload(options: options, device: device)
+        loader.squash(options: options, device: device) if @config.stage[:squash]
+        #rekey
+        key(options: options, device: device)
+        #package
+        sign_package(app_name_version: "", password: @config.key[:password], stage: options[:stage], device: device)
+        #inspect
+        if options[:inspect_package]
+          @config.in = @config.out
+          options[:password] = @config.key[:password]
+          Inspector.new(config: @config).inspect(options: options, device: device)
+        end
       end
     end
 
@@ -76,31 +78,37 @@ module RokuBuilder
     # @param keyed_pkg [String] Path for a package signed with the desired key
     # @param password [String] Password for the package
     # @return [Boolean] True if key changed, false otherwise
-    def key(options:)
-      oldId = dev_id
-
-      raise ExecutionError, "Missing Key Config" unless @config.key
-
-      # upload new key with password
-      payload =  {
-        mysubmit: "Rekey",
-        passwd: @config.key[:password],
-        archive: Faraday::UploadIO.new(@config.key[:keyed_pkg], 'application/octet-stream')
-      }
-      multipart_connection.post "/plugin_inspect", payload
+    def key(options:, device: nil)
+      get_device(device: device) do |device|
+        oldId = dev_id(device: device)
+
+        raise ExecutionError, "Missing Key Config" unless @config.key
+
+        # upload new key with password
+        payload =  {
+          mysubmit: "Rekey",
+          passwd: @config.key[:password],
+          archive: Faraday::UploadIO.new(@config.key[:keyed_pkg], 'application/octet-stream')
+        }
+        multipart_connection(device: device) do |conn|
+          conn.post "/plugin_inspect", payload
+        end
 
-      # check key
-      newId = dev_id
-      @logger.info("Key did not change") unless newId != oldId
-      @logger.debug(oldId + " -> " + newId)
+        # check key
+        newId = dev_id(device: device)
+        @logger.info("Key did not change") unless newId != oldId
+        @logger.debug(oldId + " -> " + newId)
+      end
     end
 
     # Get the current dev id
     # @return [String] The current dev id
-    def dev_id
+    def dev_id(device: nil)
       path = "/plugin_package"
-      conn = simple_connection
-      response = conn.get path
+      response = nil
+      simple_connection(device: device) do |conn|
+        response = conn.get path
+      end
 
       dev_id = /Your Dev ID:\s*<font[^>]*>([^<]*)<\/font>/.match(response.body)
       dev_id ||= /Your Dev ID:[^>]*<\/label> ([^<]*)/.match(response.body)
@@ -118,79 +126,88 @@ module RokuBuilder
     end
 
     # Sign and download the currently sideloaded app
-    def sign_package(app_name_version:, password:, stage: nil)
-      payload =  {
-        mysubmit: "Package",
-        app_name: app_name_version,
-        passwd: password,
-        pkg_time: Time.now.to_i
-      }
-      response = multipart_connection.post "/plugin_package", payload
-
-      # Check for error
-      failed = /(Failed: [^\.]*\.)/.match(response.body)
-      raise ExecutionError, failed[1] if failed
-
-      # Download signed package
-      pkg = /<a href="pkgs[^>]*>([^<]*)</.match(response.body)[1]
-      path = "/pkgs/#{pkg}"
-      conn = Faraday.new(url: @url) do |f|
-        f.request :digest, @dev_username, @dev_password
-        f.adapter Faraday.default_adapter
-      end
-      response = conn.get path
-      raise ExecutionError, "Failed to download signed package" if response.status != 200
-      out_file = nil
-      unless @config.out[:file]
-        out = @config.out
-        build_version = Manifest.new(config: @config).build_version
-        if stage
-          out[:file] = "#{@config.project[:app_name]}_#{stage}_#{build_version}"
+    def sign_package(app_name_version:, password:, stage: nil, device: nil)
+      get_device(device: device) do |device|
+        payload =  {
+          mysubmit: make_param("Package"),
+          app_name: make_param(app_name_version),
+          passwd: make_param(password),
+          pkg_time: make_param(Time.now.to_i)
+        }
+        response = nil
+        multipart_connection(device: device) do |conn|
+          response = conn.post "/plugin_package", payload
+        end
+
+        # Check for error
+        failed = /(Failed: [^\.]*\.)/.match(response.body)
+        raise ExecutionError, failed[1] if failed
+
+        # Download signed package
+        pkg = /<a href="pkgs[^>]*>([^<]*)</.match(response.body)[1]
+        path = "/pkgs/#{pkg}"
+        conn = Faraday.new(url: "http://#{device.ip}") do |f|
+          f.request :digest, device.user, device.password
+          f.adapter Faraday.default_adapter
+        end
+        response = conn.get path
+        raise ExecutionError, "Failed to download signed package" if response.status != 200
+        out_file = nil
+        unless @config.out[:file]
+          out = @config.out
+          build_version = Manifest.new(config: @config).build_version
+          if stage
+            out[:file] = "#{@config.project[:app_name]}_#{stage}_#{build_version}"
+          else
+            out[:file] = "#{@config.project[:app_name]}_working_#{build_version}"
+          end
+          @config.out = out
+        end
+        out_file = File.join(@config.out[:folder], @config.out[:file])
+        out_file = out_file+".pkg" unless out_file.end_with?(".pkg")
+        File.open(out_file, 'w+b') {|fp| fp.write(response.body)}
+        if File.exist?(out_file)
+          pkg_size = File.size(out_file).to_f / 2**20
+          raise ExecutionError, "PKG file size is too large (#{pkg_size.round(2)} MB): #{out_file}" if pkg_size > 4.0
+          @logger.info("Outfile: #{out_file}")
         else
-          out[:file] = "#{@config.project[:app_name]}_working_#{build_version}"
+          @logger.warn("Outfile Missing: #{out_file}")
         end
-        @config.out = out
-      end
-      out_file = File.join(@config.out[:folder], @config.out[:file])
-      out_file = out_file+".pkg" unless out_file.end_with?(".pkg")
-      File.open(out_file, 'w+b') {|fp| fp.write(response.body)}
-      if File.exist?(out_file)
-        pkg_size = File.size(out_file).to_f / 2**20
-        raise ExecutionError, "PKG file size is too large (#{pkg_size.round(2)} MB): #{out_file}" if pkg_size > 4.0
-        @logger.info("Outfile: #{out_file}")
-      else
-        @logger.warn("Outfile Missing: #{out_file}")
       end
     end
 
     # Uses the device to generate a new signing key
     #  @return [Array<String>] Password and dev_id for the new key
-    def generate_new_key()
-      telnet_config = {
-        'Host' => @roku_ip_address,
-        'Port' => 8080
-      }
-      connection = Net::Telnet.new(telnet_config)
-      connection.puts("genkey")
-      waitfor_config = {
-        'Match' => /./,
-        'Timeout' => false
-      }
+    def generate_new_key(device: nil)
       password = nil
       dev_id = nil
-      while password.nil? or dev_id.nil?
-        connection.waitfor(waitfor_config) do |txt|
-          while line = txt.slice!(/^.*\n/) do
-            words = line.split
-            if words[0] == "Password:"
-              password = words[1]
-            elsif words[0] == "DevID:"
-              dev_id = words[1]
+      get_device(device: device) do |device|
+        telnet_config = {
+          'Host' => device.ip,
+          'Port' => 8080
+        }
+        connection = Net::Telnet.new(telnet_config)
+        connection.puts("genkey")
+        waitfor_config = {
+          'Match' => /./,
+          'Timeout' => false
+        }
+        password = nil
+        dev_id = nil
+        while password.nil? or dev_id.nil?
+          connection.waitfor(waitfor_config) do |txt|
+            while line = txt.slice!(/^.*\n/) do
+              words = line.split
+              if words[0] == "Password:"
+                password = words[1]
+              elsif words[0] == "DevID:"
+                dev_id = words[1]
+              end
             end
           end
         end
+        connection.close
       end
-      connection.close
       return password, dev_id
     end
   end

data/lib/roku_builder/plugins/profiler.rb

@@ -62,10 +62,13 @@ module RokuBuilder
     end
 
     def sgperf(options:)
-      telnet_config ={
-        'Host' => @roku_ip_address,
-        'Port' => 8080
-      }
+      telnet_config = nil
+      get_device(no_lock: true) do |device|
+        telnet_config ={
+          'Host' => device.ip,
+          'Port' => 8080
+        }
+      end
       @connection = Net::Telnet.new(telnet_config)
       @connection.puts("sgperf clear\n")
       @connection.puts("sgperf start\n")
@@ -97,10 +100,13 @@ module RokuBuilder
     end
 
     def devlog(options:)
-      telnet_config ={
-        'Host' => @roku_ip_address,
-        'Port' => 8080
-      }
+      telnet_config = nil
+      get_device(no_lock: true) do |device|
+        telnet_config ={
+          'Host' => device.ip,
+          'Port' => 8080
+        }
+      end
       connection = Net::Telnet.new(telnet_config)
       connection.puts("enhanced_dev_log #{options[:devlog]} #{options[:devlog_function]}\n")
     end
@@ -172,7 +178,7 @@ module RokuBuilder
     def handle_node(stats:,  node:)
       if node
         node.element_children.each do |element|
-          attributes = element.attributes.map{|attr| {"#{attr.name}": attr.value}}.reduce({}, :merge)
+          attributes = element.attributes.map{|key,attr| {"#{key}": attr.value}}.reduce({}, :merge)
           stats[element.name] ||= {count: 0, ids: []}
           stats[element.name][:count] += 1
           stats[element.name][:ids].push(attributes[:name]) if attributes[:name]
@@ -217,8 +223,8 @@ module RokuBuilder
       lines.each {|line| print line}
     end
     def print_nodes_by_id(id)
-      start_reg = /<#{id}>/
-      end_reg = /<\/#{id}>/
+      start_reg = /#{id}/
+      end_reg = /#{id}/
       lines = get_command_response(command: "sgnodes #{id}", start_reg: start_reg, end_reg: end_reg)
       lines.each {|line| print line}
     end
@@ -259,10 +265,13 @@ module RokuBuilder
         'Timeout' => 1
       }
       unless @connection
-        telnet_config ={
-          'Host' => @roku_ip_address,
-          'Port' => 8080
-        }
+        telnet_config = nil
+        get_device(no_lock: true) do |device|
+          telnet_config ={
+            'Host' => device.ip,
+            'Port' => 8080
+          }
+        end
         @connection = Net::Telnet.new(telnet_config)
       end
 

data/lib/roku_builder/plugins/tester.rb

@@ -38,21 +38,23 @@ module RokuBuilder
     # Run tests and report results
     # @param sideload_config [Hash] The config for sideloading the app
     def test(options:)
-      loader = Loader.new(config: @config)
-      loader.sideload(options: options)
-      linker = Linker.new(config: @config)
-      linker.deeplink(options: Options.new(options: {deeplink: "RunTests:true"}))
+      get_device do |device|
+        loader = Loader.new(config: @config)
+        loader.sideload(options: options, device: device)
+        linker = Linker.new(config: @config)
+        linker.deeplink(options: Options.new(options: {deeplink: "RunTests:true"}), device: device)
 
-      telnet_config ={
-        'Host' => @roku_ip_address,
-        'Port' => 8085
-      }
-      connection = Net::Telnet.new(telnet_config)
-      connection.waitfor(@end_reg) do |txt|
-        handle_text(txt: txt)
+        telnet_config ={
+          'Host' => device.ip,
+          'Port' => 8085
+        }
+        connection = Net::Telnet.new(telnet_config)
+        connection.waitfor(@end_reg) do |txt|
+          handle_text(txt: txt)
+        end
+        print_logs
+        connection.puts("cont\n")
       end
-      print_logs
-      connection.puts("cont\n")
     end
 
     private

data/lib/roku_builder/util.rb

@@ -11,10 +11,6 @@ module RokuBuilder
     def initialize(config: )
       @logger = Logger.instance
       @config = config
-      @roku_ip_address = @config.device_config[:ip]
-      @dev_username = @config.device_config[:user]
-      @dev_password = @config.device_config[:password]
-      @url = "http://#{@roku_ip_address}"
       init
     end
 
@@ -27,25 +23,51 @@ module RokuBuilder
 
     # Generates a simpe Faraday connection with digest credentials
     # @return [Faraday] The faraday connection
-    def simple_connection
-      Faraday.new(url: @url) do |f|
-        f.request :digest, @dev_username, @dev_password
-        f.adapter Faraday.default_adapter
+    def simple_connection(device: nil, no_lock: false, &block)
+      raise ImplementationError, "No block given to simple_connection" unless block_given?
+      get_device(device: device, no_lock: no_lock) do |device|
+        url = "http://#{device.ip}"
+        connection = Faraday.new(url: url) do |f|
+          f.request :digest, device.user, device.password
+          f.adapter Faraday.default_adapter
+        end
+        block.call(connection)
       end
     end
 
     # Generates a multipart Faraday connection with digest credentials
     # @param port [Integer] optional port to connect to
     # @return [Faraday] The faraday connection
-    def multipart_connection(port: nil)
-      url = @url
-      url = "#{url}:#{port}" if port
-      Faraday.new(url: url) do |f|
-        f.headers['Content-Type'] = Faraday::Request::Multipart.mime_type
-        f.request :digest, @dev_username, @dev_password
-        f.request :multipart
-        f.request :url_encoded
-        f.adapter Faraday.default_adapter
+    def multipart_connection(port: nil, device: nil, no_lock: false, &block)
+      raise ImplementationError, "No block given to multipart_connection" unless block_given?
+      get_device(device: device, no_lock: no_lock) do |device|
+        url = "http://#{device.ip}"
+        url += ":#{port}" if port
+        connection = Faraday.new(url: url) do |f|
+          f.request :digest, device.user, device.password
+          f.request :multipart
+          f.request :url_encoded
+          f.adapter Faraday.default_adapter
+        end
+        block.call(connection)
+      end
+    end
+
+    def make_param(value, contentType = nil)
+      Faraday::Multipart::ParamPart.new(value, contentType)
+    end
+
+    def get_device(device: nil, no_lock: false, &block)
+      raise ImplementationError, "No block given to get_device" unless block_given?
+      device_given = true
+      unless device
+        device_given = false
+        device = RokuBuilder.device_manager.reserve_device(no_lock: no_lock)
+      end
+      begin
+        block.call(device)
+      ensure
+        RokuBuilder.device_manager.release_device(device) unless device_given
       end
     end
   end

data/lib/roku_builder/version.rb

@@ -2,5 +2,5 @@
 
 module RokuBuilder
   # Version of the RokuBuilder Gem
-  VERSION = "4.25.5"
+  VERSION = "4.25.6"
 end

data/lib/roku_builder.rb

@@ -2,6 +2,7 @@
 
 require "logger"
 require "faraday"
+require "faraday/multipart"
 require "faraday/digestauth"
 require "pathname"
 require "optparse"
@@ -68,7 +69,6 @@ module RokuBuilder
 
   def self.execute
     load_config
-    check_devices
     execute_command
   end
 
@@ -171,24 +171,8 @@ module RokuBuilder
     end
   end
 
-  def self.check_devices
-    if @@options.device_command?
-      ping = Net::Ping::External.new
-      host = @@config.parsed[:device_config][:ip]
-      return if ping.ping? host, 1, 0.2, 1
-      raise DeviceError, "Device not online" if @@options[:device_given]
-      @@config.raw[:devices].each_pair {|key, value|
-        unless key == :default
-          host = value[:ip]
-          if ping.ping? host, 1, 0.2, 1
-            @@config.parsed[:device_config] = value
-            Logger.instance.warn("Default device offline, choosing Alternate")
-            return
-          end
-        end
-      }
-      raise DeviceError, "No devices found"
-    end
+  def self.device_manager
+    @@device_manager ||= DeviceManager.new(config: @@config, options: @@options)
   end
 
   def self.execute_command

data/roku_builder.gemspec

@@ -21,7 +21,8 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = "~> 3.0"
 
   spec.add_dependency "rubyzip",             "~> 1.2"
-  spec.add_dependency "faraday",             "~> 0.13"
+  spec.add_dependency "faraday",             "~> 2.3"
+  spec.add_dependency "faraday-multipart",   "~> 1.0"
   spec.add_dependency "faraday-digestauth",  "~> 0.2"
   spec.add_dependency "git",                 "~> 1.3"
   spec.add_dependency "net-ping",            "~> 2.0"
@@ -33,7 +34,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler",           "~> 2.0"
   spec.add_development_dependency "rake",              "~> 12.0"
   spec.add_development_dependency "byebug",            "~> 10.0"
-  spec.add_development_dependency "minitest",          "~> 5.10"
+  spec.add_development_dependency "minitest",          "~> 5.16"
   spec.add_development_dependency "minitest-autotest", "~> 1.0"
   spec.add_development_dependency "minitest-server",   "~> 1.0"
   spec.add_development_dependency "minitest-utils",    "~> 0.3"

data/test/roku_builder/plugins/test_core.rb

@@ -18,7 +18,7 @@ module RokuBuilder
         "--do-unstage", "--edit", "params", "--config", "config-path",
         "--ref", "ref", "--working", "--current", "--stage", "stage", "--project",
         "project", "--out", "out", "--in", "in", "--device", "device",
-        "--verbose", "--debug"]
+        "--device-blocking", "--verbose", "--debug"]
       parser.parse! argv
       assert options[:configure]
       assert options[:validate]
@@ -35,7 +35,7 @@ module RokuBuilder
       assert_equal "out", options[:out]
       assert_equal "in", options[:in]
       assert_equal "device", options[:device]
-      assert options[:device_given]
+      assert options[:device_blocking]
       assert options[:verbose]
       assert options[:debug]
     end
@@ -56,7 +56,6 @@ module RokuBuilder
       assert_equal "out", options[:out]
       assert_equal "in", options[:in]
       assert_equal "device", options[:device]
-      assert options[:device_given]
       assert options[:verbose]
     end
     def test_core_configure

data/test/roku_builder/plugins/test_inspector.rb

@@ -32,6 +32,7 @@ module RokuBuilder
       assert options[:screencapture]
     end
     def test_inspector_inspect
+
       logger = Minitest::Mock.new()
 
       logger.expect(:formatter=, nil, [Proc])
@@ -77,9 +78,19 @@ module RokuBuilder
       options = {inspect: true, in: File.join(test_files_path(InspectorTest), "test.pkg"), password: "password"}
       config, options = build_config_options_objects(InspectorTest, options, false)
       inspector = Inspector.new(config: config)
-      ::Logger.stub(:new, logger) do
-        inspector.inspect(options: options)
+
+      device_manager = Minitest::Mock.new
+      device = RokuBuilder::Device.new("roku", config.raw[:devices][:roku])
+      device_manager.expect(:reserve_device, device, no_lock: false)
+      device_manager.expect(:release_device, nil, [device])
+
+      RokuBuilder.stub(:device_manager, device_manager) do
+        ::Logger.stub(:new, logger) do
+          inspector.inspect(options: options)
+        end
       end
+      logger.verify
+      device_manager.verify
     end
     def test_inspector_inspect_old_interface
       logger = Minitest::Mock.new()
@@ -119,9 +130,20 @@ module RokuBuilder
       options = {inspect: true, in: File.join(test_files_path(InspectorTest), "test.pkg"), password: "password"}
       config, options = build_config_options_objects(InspectorTest, options, false)
       inspector = Inspector.new(config: config)
-      ::Logger.stub(:new, logger) do
-        inspector.inspect(options: options)
+
+      device_manager = Minitest::Mock.new
+      device = RokuBuilder::Device.new("roku", config.raw[:devices][:roku])
+      device_manager.expect(:reserve_device, device, no_lock: false)
+      device_manager.expect(:release_device, nil, [device])
+
+      RokuBuilder.stub(:device_manager, device_manager) do
+        ::Logger.stub(:new, logger) do
+          inspector.inspect(options: options)
+        end
       end
+
+      logger.verify
+      device_manager.verify
     end
 
     def test_screencapture
@@ -139,9 +161,19 @@ module RokuBuilder
       options = {screencapture: true }
       config, options = build_config_options_objects(InspectorTest, options, false)
       inspector = Inspector.new(config: config)
-      File.stub(:open, nil, io) do
-        inspector.screencapture(options: options)
+
+      device_manager = Minitest::Mock.new
+      device = RokuBuilder::Device.new("roku", config.raw[:devices][:roku])
+      device_manager.expect(:reserve_device, device, no_lock: false)
+      device_manager.expect(:release_device, nil, [device])
+
+      RokuBuilder.stub(:device_manager, device_manager) do
+        File.stub(:open, nil, io) do
+          inspector.screencapture(options: options)
+        end
       end
+      io.verify
+      device_manager.verify
     end
     def test_screencapture_png
       body = "<hr /><img src=\"pkgs/dev.png?time=1455629573\">"
@@ -158,8 +190,16 @@ module RokuBuilder
       options = {screencapture: true }
       config, options = build_config_options_objects(InspectorTest, options, false)
       inspector = Inspector.new(config: config)
-      File.stub(:open, nil, io) do
-        inspector.screencapture(options: options)
+
+      device_manager = Minitest::Mock.new
+      device = RokuBuilder::Device.new("roku", config.raw[:devices][:roku])
+      device_manager.expect(:reserve_device, device, no_lock: false)
+      device_manager.expect(:release_device, nil, [device])
+
+      RokuBuilder.stub(:device_manager, device_manager) do
+        File.stub(:open, nil, io) do
+          inspector.screencapture(options: options)
+        end
       end
     end
   end