roku_builder 3.13.0 → 4.0.0

data/lib/roku_builder/plugins/packager.rb

@@ -0,0 +1,194 @@
+# ********** Copyright Viacom, Inc. Apache 2.0 **********
+
+module RokuBuilder
+
+  class Packager < Util
+    extend Plugin
+
+    def self.commands
+      {
+        package: {device: true, source: true, stage: true, exclude: true},
+        genkey: {device: true},
+        key: {device: true, source: true}
+      }
+    end
+
+    def self.parse_options(parser:, options:)
+      parser.separator "Commands:"
+      parser.on("-p", "--package", "Package an app") do
+        options[:package] = true
+      end
+      parser.on("-k", "--key", "Change device key") do
+        options[:key] = true
+      end
+      parser.on("--genkey", "Generate a new key") do
+        options[:genkey] = true
+      end
+      parser.separator "Options:"
+      parser.on("-i", "--inspect-package", "Inspect package after packaging") do
+        options[:inspect_package] = true
+      end
+    end
+
+    def self.dependencies
+      [Loader, Inspector]
+    end
+
+    def package(options:)
+      check_options(options)
+      #sideload
+      Loader.new(config: @config).sideload(options: options)
+      #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)
+      end
+    end
+
+    def genkey(options:)
+      password, dev_id = generate_new_key()
+      @logger.unknown("Password: "+password)
+      @logger.info("DevID: "+dev_id)
+
+      out = @config.out
+      out[:file] ||= "key_"+dev_id+".pkg"
+      @config.out = out
+
+      Dir.mktmpdir { |dir|
+        config_copy = @config.dup
+        config_copy.root_dir = dir
+        Manifest.generate({config: config_copy, attributes: {}})
+        Dir.mkdir(File.join(dir, "source"))
+        File.open(File.join(dir, "source", "main.brs"), "w") do |io|
+          io.puts "sub main()"
+          io.puts "  print \"Load\""
+          io.puts "end sub"
+        end
+        loader = Loader.new(config: config_copy)
+        options[:current] = true
+        loader.sideload(options: options)
+        sign_package(app_name_version: "key_"+dev_id, password: password, stage: options[:stage])
+        @logger.unknown("Keyed PKG: #{File.join(@config.out[:folder], @config.out[:file])}")
+      }
+    end
+
+    # Sets the key on the roku device
+    # @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
+
+      # 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
+
+      # check key
+      newId = dev_id
+      @logger.info("Key did not change") unless newId != oldId
+      @logger.debug(oldId + " -> " + newId)
+    end
+
+    # Get the current dev id
+    # @return [String] The current dev id
+    def dev_id
+      path = "/plugin_package"
+      conn = simple_connection
+      response = conn.get path
+
+      dev_id = /Your Dev ID:\s*<font[^>]*>([^<]*)<\/font>/.match(response.body)
+      dev_id ||= /Your Dev ID:[^>]*<\/label> ([^<]*)/.match(response.body)
+      dev_id = dev_id[1] if dev_id
+      dev_id ||= "none"
+      dev_id
+    end
+
+    private
+
+    def check_options(options)
+      raise InvalidOptions, "Can not use '--in' for packaging" if options[:in]
+      raise InvalidOptions, "Can not use '--ref' for packaging" if options[:ref]
+      raise InvalidOptions, "Can not use '--current' for packaging" if options[:current]
+    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
+        if stage
+          out[:file] = "#{@config.project[:app_name]}_#{stage}"
+        else
+          out[:file] = "#{@config.project[:app_name]}_working"
+        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+') {|fp| fp.write(response.body)}
+      true
+    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
+      }
+      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
+      return password, dev_id
+    end
+  end
+  RokuBuilder.register_plugin(Packager)
+end

data/lib/roku_builder/plugins/profiler.rb

@@ -0,0 +1,135 @@
+# ********** Copyright Viacom, Inc. Apache 2.0 **********
+
+module RokuBuilder
+
+  # Scene Graph Profiler
+  class Profiler < Util
+    extend Plugin
+
+    def self.commands
+      {profile: {device: true}}
+    end
+
+    def self.parse_options(parser:, options:)
+      parser.separator "Commands:"
+      parser.on("--profile COMMAND", "Run various profiler options") do |c|
+        options[:profile] = c
+      end
+    end
+
+    # Run the profiler commands
+    # @param command [Symbol] The profiler command to run
+    def profile(options:)
+      case options[:profile].to_sym
+      when :stats
+        print_stats
+      when :all
+        print_all_nodes
+      when :images
+        print_image_information
+      when :textures
+        print_texture_information
+      end
+    end
+
+    private
+
+    # Print the node stats
+    def print_stats
+      end_reg = /<\/All_Nodes>/
+      start_reg = /<All_Nodes>/
+      lines = get_command_response(command: "sgnodes all", start_reg: start_reg, end_reg: end_reg)
+      xml_string = lines.join("\n")
+      stats = {"Total" => 0}
+      doc = Nokogiri::XML(xml_string)
+      handle_node(stats: stats, node: doc.root)
+      stats = stats.to_a
+      stats = stats.sort {|a, b| b[1] <=> a[1]}
+      printf "%30s | %5s\n", "Name", "Count"
+      stats.each do |key_pair|
+        printf "%30s | %5d\n", key_pair[0], key_pair[1]
+      end
+    end
+
+    def handle_node(stats:,  node:)
+      node.element_children.each do |element|
+        stats[element.name] ||= 0
+        stats[element.name] += 1
+        stats["Total"] += 1
+        handle_node(stats: stats, node: element)
+      end
+    end
+
+    def print_all_nodes
+      start_reg = /<All_Nodes>/
+      end_reg = /<\/All_Nodes>/
+      lines = get_command_response(command: "sgnodes all", start_reg: start_reg, end_reg: end_reg)
+      lines.each {|line| print line}
+    end
+    def print_image_information
+      start_reg = /RoGraphics instance/
+      end_reg = /Available memory/
+      lines = get_command_response(command: "r2d2_bitmaps", start_reg: start_reg, end_reg: end_reg)
+      lines.each {|line| print line}
+    end
+    def print_texture_information
+      start_reg = /\*+/
+      end_reg = /#{SecureRandom.uuid}/
+      lines = get_command_response(command: "loaded_textures", start_reg: start_reg, end_reg: end_reg)
+      lines.each {|line| print line}
+    end
+
+    # Retrive list of all nodes
+    # @return [Array<String>] Array of lines
+    def get_command_response(command:, start_reg:, end_reg:, unique: false)
+      waitfor_config = {
+        'Match' => /.+/,
+        'Timeout' => 5
+      }
+      telnet_config ={
+        'Host' => @roku_ip_address,
+        'Port' => 8080
+      }
+
+      connection = Net::Telnet.new(telnet_config)
+
+      @lines = []
+      @all_txt = ""
+      @begun = false
+      @done = false
+      connection.puts("#{command}\n")
+      while not @done
+        begin
+          connection.waitfor(waitfor_config) do |txt|
+            handle_text(txt: txt, start_reg: start_reg, end_reg: end_reg, unique: unique)
+          end
+        rescue Net::ReadTimeout
+          @logger.warn "Timed out reading profiler information"
+          @done = true
+        end
+      end
+      @lines
+    end
+
+    # Handle profiling text
+    # @param all_txt [String] remainder text from last run
+    # @param txt [String] current text from telnet
+    # @param in_nodes [Boolean] currently parsing test text
+    # @return [Boolean] currently parsing test text
+    def handle_text(txt:, start_reg:, end_reg:, unique:)
+      @all_txt += txt
+      while line = @all_txt.slice!(/^.*\n/) do
+        if line =~ start_reg
+          @begun = true
+          @lines = [] if unique
+        end
+        @lines.push(line) if @begun
+        if line =~ end_reg
+          @begun = false
+          @done = true
+        end
+      end
+    end
+  end
+  RokuBuilder.register_plugin(Profiler)
+end

data/lib/roku_builder/plugins/scripter.rb

@@ -0,0 +1,53 @@
+# ********** Copyright Viacom, Inc. Apache 2.0 **********
+
+module RokuBuilder
+
+  # Helper for extending for scripting
+  class Scripter
+    extend Plugin
+
+    def self.commands
+      {print: {source: true, stage: true}}
+    end
+
+    def self.parse_options(parser:, options:)
+      parser.separator("Commands:")
+      parser.on("--print ATTRIBUTE", "Print attribute for scripting") do |a|
+        options[:print] = a.to_sym
+      end
+    end
+
+    def initialize(config:)
+      @config = config
+    end
+
+    def print(options:)
+      attributes = [
+        :title, :build_version, :app_version, :root_dir, :app_name
+      ]
+
+      unless attributes.include? options[:print]
+        raise ExecutionError, "Unknown attribute: #{options[:print]}"
+      end
+
+      manifest = Manifest.new(config: @config)
+
+      case options[:print]
+      when :root_dir
+        printf "%s", @config.project[:directory]
+      when :app_name
+        printf "%s", @config.project[:app_name]
+      when :title
+        printf "%s", manifest.title
+      when :build_version
+        printf "%s", manifest.build_version
+      when :app_version
+        major = manifest.major_version
+        minor = manifest.minor_version
+        printf "%s.%s", major, minor
+      end
+    end
+  end
+
+  RokuBuilder.register_plugin(Scripter)
+end

data/lib/roku_builder/{tester.rb → plugins/tester.rb}

@@ -6,10 +6,25 @@ module RokuBuilder
   # This is intended to be used with the brstest librbary but should work
   # with other testing libraries
   class Tester < Util
+    extend Plugin
+
+    def self.commands
+      {test: {device: true, source: true, stage: true}}
+    end
+
+    def self.parse_options(parser:, options:)
+      parser.separator "Commands:"
+      parser.on("-t", "--test", "Test an app") do
+        options[:test] = true
+      end
+    end
+
+    def self.dependencies
+      [Loader, Linker]
+    end
 
     # Initialize starting and ending regular expressions
-    def init(root_dir:)
-      @root_dir = root_dir
+    def init()
       @end_reg = /\*+\s*End testing\s*\*+/
       @start_reg = /\*+\s*Start testing\s*\*+/
       @test_logger = ::Logger.new(STDOUT)
@@ -22,29 +37,22 @@ module RokuBuilder
 
     # Run tests and report results
     # @param sideload_config [Hash] The config for sideloading the app
-    def run_tests(sideload_config:)
+    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"}))
+
       telnet_config ={
         'Host' => @roku_ip_address,
         'Port' => 8085
       }
-
-      @device_config[:init_params] = {
-        root_dir: @root_dir
-      }
-      loader = Loader.new(**@device_config)
       connection = Net::Telnet.new(telnet_config)
-      code, _build_version = loader.sideload(**sideload_config)
-      if code == SUCCESS
-        @device_config[:init_params] = nil
-        linker = Linker.new(**@device_config)
-        linker.launch(options: "RunTests:true")
-
-        connection.waitfor(@end_reg) do |txt|
-          handle_text(txt: txt)
-        end
-        print_logs
-        connection.puts("cont\n")
+      connection.waitfor(@end_reg) do |txt|
+        handle_text(txt: txt)
       end
+      print_logs
+      connection.puts("cont\n")
     end
 
     private
@@ -95,4 +103,5 @@ module RokuBuilder
       end
     end
   end
+  RokuBuilder.register_plugin(Tester)
 end