roku_builder 3.13.0 → 4.0.0

data/lib/roku_builder/keyer.rb

@@ -1,106 +0,0 @@
-# ********** Copyright Viacom, Inc. Apache 2.0 **********
-
-module RokuBuilder
-
-  # Change or get dev key
-  class Keyer < Util
-
-    def genkey(out_file: nil)
-      password, dev_id = generate_new_key()
-      @logger.unknown("Password: "+password)
-      @logger.info("DevID: "+dev_id)
-
-      unless out_file
-        out_file = File.join(Dir.tmpdir, "key_"+dev_id+".pkg")
-      end
-
-      Dir.mktmpdir { |dir|
-        ManifestManager.update_manifest({root_dir: dir, 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
-        @device_config[:init_params] = {root_dir: dir}
-        loader = Loader.new(**@device_config)
-        loader.sideload()
-        @device_config.delete(:init_params)
-        packager = Packager.new(**@device_config)
-        packager.package(app_name_version: "key_"+dev_id, out_file: out_file, password: password)
-        @logger.unknown("Keyed PKG: "+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 rekey(keyed_pkg:, password:)
-      oldId = dev_id
-
-      # upload new key with password
-      path = "/plugin_inspect"
-      conn = multipart_connection
-      payload =  {
-        mysubmit: "Rekey",
-        passwd: password,
-        archive: Faraday::UploadIO.new(keyed_pkg, 'application/octet-stream')
-      }
-      conn.post path, payload
-
-      # check key
-      newId = dev_id
-      @logger.info("Key did not change") unless newId != oldId
-      @logger.debug(oldId + " -> " + newId)
-      newId != oldId
-    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
-
-    # 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
-end

data/lib/roku_builder/loader.rb

@@ -1,131 +0,0 @@
-# ********** Copyright Viacom, Inc. Apache 2.0 **********
-
-module RokuBuilder
-
-  # Load/Unload/Build roku applications
-  class Loader < Util
-
-
-    # Set the root directory
-    def init(root_dir: nil)
-      @root_dir = root_dir
-    end
-
-    # Sideload an app onto a roku device
-    # @param root_dir [String] Path to the root directory of the roku app
-    # @param content [Hash] Hash containing arrays for folder, files, and excludes. Default: nil
-    # @return [String] Build version on success, nil otherwise
-    def sideload(update_manifest: false, content: nil, infile: nil, out_file: nil)
-      Navigator.new(**@device_config).nav(commands: [:home])
-      result = FAILED_SIDELOAD
-      build_version = nil
-      if infile
-        build_version = ManifestManager.build_version(root_dir: infile)
-        out_file = infile
-      else
-        # Update manifest
-        if update_manifest
-          build_version = ManifestManager.update_build(root_dir: @root_dir)
-        else
-          build_version = ManifestManager.build_version(root_dir: @root_dir)
-        end
-        @logger.info "Build: #{out_file}" if out_file
-        out_file = build(build_version: build_version, out_file: out_file, content: content)
-      end
-      return [MISSING_MANIFEST, nil] if out_file == MISSING_MANIFEST
-      path = "/plugin_install"
-      # Connect to roku and upload file
-      conn = multipart_connection
-      payload =  {
-        mysubmit: "Replace",
-        archive: Faraday::UploadIO.new(out_file, 'application/zip')
-      }
-      response = conn.post path, payload
-      # Cleanup
-      File.delete(out_file) if infile.nil? and out_file.nil?
-      result = SUCCESS if response.status==200 and response.body=~/Install Success/
-      result = IDENTICAL_SIDELOAD if response.status==200 and response.body=~/Identical to previous version/
-      [result, build_version]
-    end
-
-
-    # Build an app to sideload later
-    # @param root_dir [String] Path to the root directory of the roku app
-    # @param build_version [String] Version to assigne to the build. If nil will pull the build version form the manifest. Default: nil
-    # @param out_file [String] Path for the output file. If nil will create a file in /tmp. Default: nil
-    # @param content [Hash] Hash containing arrays for folder, files, and excludes. Default: nil
-    # @return [String] Path of the build
-    def build(build_version: nil, out_file: nil, content: nil)
-      build_version = ManifestManager.build_version(root_dir: @root_dir) unless build_version
-      return MISSING_MANIFEST if build_version == MISSING_MANIFEST
-      content ||= {}
-      content[:folders] ||= Dir.entries(@root_dir).select {|entry| File.directory? File.join(@root_dir, entry) and !(entry =='.' || entry == '..') }
-      content[:files] ||= Dir.entries(@root_dir).select {|entry| File.file? File.join(@root_dir, entry)}
-      content[:excludes] ||= []
-      out_file = "#{Dir.tmpdir}/#{build_version}" unless out_file
-      out_file = out_file+".zip" unless out_file.end_with?(".zip")
-      File.delete(out_file) if File.exist?(out_file)
-      io = Zip::File.open(out_file, Zip::File::CREATE)
-      # Add folders to zip
-      content[:folders].each do |folder|
-        base_folder = File.join(@root_dir, folder)
-        if File.exist?(base_folder)
-          entries = Dir.entries(base_folder)
-          entries.delete(".")
-          entries.delete("..")
-          writeEntries(@root_dir, entries, folder, content[:excludes], io)
-        else
-          @logger.warn "Missing Folder: #{base_folder}"
-        end
-      end
-      # Add file to zip
-      writeEntries(@root_dir, content[:files], "", content[:excludes], io)
-      io.close()
-      out_file
-    end
-
-    # Remove the currently sideloaded app
-    def unload()
-      path = "/plugin_install"
-
-      # Connect to roku and upload file
-      conn = multipart_connection
-      payload =  {
-        mysubmit: "Delete",
-        archive: ""
-      }
-      response = conn.post path, payload
-      if response.status == 200 and response.body =~ /Install Success/
-        return true
-      end
-      return false
-    end
-
-    private
-
-    # Recursively write directory contents to a zip archive
-    # @param root_dir [String] Path of the root directory
-    # @param entries [Array<String>] Array of file paths of files/directories to store in the zip archive
-    # @param path [String] The path of the current directory starting at the root directory
-    # @param io [IO] zip IO object
-    def writeEntries(root_dir, entries, path, excludes, io)
-      entries.each { |e|
-        zipFilePath = path == "" ? e : File.join(path, e)
-        diskFilePath = File.join(root_dir, zipFilePath)
-        if File.directory?(diskFilePath)
-          io.mkdir(zipFilePath)
-          subdir =Dir.entries(diskFilePath); subdir.delete("."); subdir.delete("..")
-          writeEntries(root_dir, subdir, zipFilePath, excludes, io)
-        else
-          unless excludes.include?(zipFilePath)
-            if File.exist?(diskFilePath)
-              io.get_output_stream(zipFilePath) { |f| f.puts(File.open(diskFilePath, "rb").read()) }
-            else
-              @logger.warn "Missing File: #{diskFilePath}"
-            end
-          end
-        end
-      }
-    end
-  end
-end

data/lib/roku_builder/manifest_manager.rb

@@ -1,126 +0,0 @@
-# ********** Copyright Viacom, Inc. Apache 2.0 **********
-
-module RokuBuilder
-
-  # Updates or retrives build version
-  class ManifestManager
-
-    # Updates the build version in the manifest file
-    # @param root_dir [String] Path to the root directory for the app
-    # @return [String] Build version on success, empty string otherwise
-    def self.update_build(root_dir:)
-      return MISSING_MANIFEST unless self.check_manifest(root_dir: root_dir)
-      build_version = self.build_version(root_dir: root_dir).split(".")
-      if 2 == build_version.length
-        iteration = build_version[1].to_i + 1
-        build_version[0] = Time.now.strftime("%m%d%y")
-        build_version[1] = iteration
-        build_version = build_version.join(".")
-      else
-        iteration = build_version[0].to_i + 1
-        build_version = iteration.to_s
-      end
-      self.update_manifest(root_dir: root_dir, attributes: {build_version: build_version})
-      self.build_version(root_dir: root_dir)
-    end
-
-
-    # Retrive the build version from the manifest file
-    # @param root_dir [String] Path to the root directory for the app
-    # @return [String] Build version on success, empty string otherwise
-    def self.build_version(root_dir:)
-      return MISSING_MANIFEST unless self.check_manifest(root_dir: root_dir)
-      read_manifest(root_dir: root_dir)[:build_version]
-    end
-
-    def self.read_manifest(root_dir:)
-      return MISSING_MANIFEST unless self.check_manifest(root_dir: root_dir)
-      attrs = {}
-      get_attrs = lambda  { |file|
-        file.each_line do |line|
-          key, value = line.split("=")
-          if value
-            attrs[key.chomp.to_sym]= value.chomp
-          elsif key and !key.chomp.empty?
-            attrs[key.chomp.to_sym]= nil
-          end
-        end
-      }
-      if File.directory?(root_dir)
-        path = File.join(root_dir, 'manifest')
-        File.open(path, 'r', &get_attrs)
-      elsif File.extname(root_dir) == ".zip"
-        Zip::File.open(root_dir) do |zip_file|
-          entry = zip_file.glob("manifest").first
-          entry.get_input_stream(&get_attrs)
-        end
-      end
-      attrs
-    end
-
-    # Update attributes in the app manifest
-    # It will add missing attributes but not remove them
-    # @param root_dir [String] The app root directory
-    # @param attributes [Hash] The new attributes for the app manifest
-    def self.update_manifest(root_dir:, attributes:, set_default: true)
-      temp_file = Tempfile.new('manifest')
-      path = File.join(root_dir, 'manifest')
-      new_params = attributes.dup
-      begin
-        if File.exist?(path)
-          File.open(path, 'r') do |file|
-            file.each_line do |line|
-              key = line.split("=")[0]
-              if new_params.include?(key.to_sym)
-                temp_file.puts("#{key}=#{new_params[key.to_sym]}")
-                new_params.delete(key.to_sym)
-              else
-                temp_file.puts(line)
-              end
-            end
-          end
-        elsif set_default
-          new_params = self.default_params().merge(new_params)
-        end
-        new_params.each_pair do |key, value|
-          temp_file.puts("#{key}=#{value}")
-        end
-        temp_file.rewind
-        FileUtils.cp(temp_file.path, path)
-      ensure
-        temp_file.close
-        temp_file.unlink
-      end
-    end
-
-    # Check to make sure that the manifest file exists
-    # @param root_dir [String] Path to the root directory for the app
-    # @return [Boolean] True if manifest exists, false otherwise
-    def self.check_manifest(root_dir:)
-      return false unless File.exist?(root_dir)
-      if File.directory?(root_dir)
-        path = File.join(root_dir, 'manifest')
-        return false unless File.exist?(path)
-      elsif File.extname(root_dir) == ".zip"
-        Zip::File.open(root_dir) do |zip_file|
-          entry = zip_file.glob("manifest").first
-          return false unless entry
-        end
-      end
-      true
-    end
-
-    # Returns the default manafest values
-    # @return [Hash] default manifest values
-    def self.default_params
-      {
-        title: "Default Title",
-        major_version: 1,
-        minor_version: 0,
-        build_version: "010101.0001",
-        mm_icon_focus_hd: "<insert hd focus icon url>",
-        mm_icon_focus_sd: "<insert sd focus icon url>"
-      }
-    end
-  end
-end

data/lib/roku_builder/packager.rb

@@ -1,43 +0,0 @@
-# ********** Copyright Viacom, Inc. Apache 2.0 **********
-
-module RokuBuilder
-
-  # Method of packaging app for submission
-  class Packager < Util
-
-    # Sign and download the currently sideloaded app
-    # @param app_name_version [String] The name and version of the package
-    # @param out_file [String] Location to download signed package to
-    # @param password [String] Password for the devices current key
-    # @return [Boolean] True on package success and download, false otherwise
-    def package(app_name_version:, out_file:, password:)
-      # Sign package
-      path = "/plugin_package"
-      conn = multipart_connection
-      payload =  {
-        mysubmit: "Package",
-        app_name: app_name_version,
-        passwd: password,
-        pkg_time: Time.now.to_i
-      }
-      response = conn.post path, payload
-
-      # Check for error
-      failed = /(Failed: [^\.]*\.)/.match(response.body)
-      return 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
-      return false if response.status != 200
-      out_file = out_file+".pkg" unless out_file.end_with?(".pkg")
-      File.open(out_file, 'w+') {|fp| fp.write(response.body)}
-      true
-    end
-  end
-end

data/lib/roku_builder/profiler.rb

@@ -1,96 +0,0 @@
-# ********** Copyright Viacom, Inc. Apache 2.0 **********
-
-module RokuBuilder
-
-  # Scene Graph Profiler
-  class Profiler < Util
-
-    # Run the profiler commands
-    # @param command [Symbol] The profiler command to run
-    def run(command:)
-      case command
-      when :stats
-        print_stats
-      end
-    end
-
-    private
-
-    # Print the node stats
-    def print_stats
-      lines = get_all_nodes
-      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
-
-    # Retrive list of all nodes
-    # @return [Array<String>] Array of lines
-    def get_all_nodes
-      waitfor_config = {
-        'Match' => /.+/,
-        'Timeout' => 5
-      }
-      telnet_config ={
-        'Host' => @roku_ip_address,
-        'Port' => 8080
-      }
-
-      connection = Net::Telnet.new(telnet_config)
-
-      lines = []
-      all_txt = ""
-      in_nodes = false
-      done = false
-      connection.puts("sgnodes all\n")
-      while not done
-        begin
-          connection.waitfor(waitfor_config) do |txt|
-            in_nodes, done, all_txt = handle_text(all_txt: all_txt, txt: txt, in_nodes: in_nodes, lines: lines)
-          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(all_txt:, txt:, in_nodes:, lines:)
-      all_txt += txt
-      end_reg = /<\/All_Nodes>/
-      start_reg = /<All_Nodes>/
-      done = false
-      while line = all_txt.slice!(/^.*\n/) do
-        in_nodes = true if line =~ start_reg
-        lines.push(line) if in_nodes
-        if line =~ end_reg
-          in_nodes = false
-          done = true
-        end
-      end
-      [in_nodes, done, all_txt]
-    end
-  end
-end