roku_builder 3.13.0 → 4.0.0

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

@@ -4,15 +4,42 @@ module RokuBuilder
 
   # Launch application, sending parameters
   class Linker < Util
+    extend Plugin
+
+    def self.commands
+      {
+        deeplink: {device: true, stage: true},
+        applist: {device: true}
+      }
+    end
+
+    def self.parse_options(parser:,  options:)
+      parser.separator "Commands:"
+      parser.on("-o", "--deeplink OPTIONS", "Deeplink into app. Define options as keypairs. (eg. a:b, c:d,e:f)") do |o|
+        options[:deeplink] = o
+      end
+      parser.on("-A", "--app-list", "List currently installed apps") do
+        options[:applist] = true
+      end
+      parser.separator "Options:"
+      parser.on("-a", "--app ID", "Send App id for deeplinking") do |a|
+        options[:app_id] = a
+      end
+    end
+
+    def self.dependencies
+      [Loader]
+    end
+
     # Deeplink to an app
-    # @param options [String] Options string
-    # @param app_id [String] Id of the app to launch (defaults to dev)
-    # @param logger [Logger] System Logger
-    # @note Options string should be formated like the following: "<key>:<value>[, <key>:<value>]*"
-    # @note Any options will be accepted and sent to the app
-    def launch(options: nil, app_id: "dev")
+    def deeplink(options:)
+      if options.has_source?
+        Loader.new(config: @config).sideload(options: options)
+      end
+      app_id = options[:app_id]
+      app_id ||= "dev"
       path = "/launch/#{app_id}"
-      payload = Util.options_parse(options: options)
+      payload = RokuBuilder.options_parse(options: options[:deeplink])
 
       unless payload.keys.count > 0
         @logger.warn "No options sent to launched app"
@@ -25,15 +52,13 @@ module RokuBuilder
         @logger.info "curl -d '' '#{@url}:8060#{path}'"
       end
 
-      conn = multipart_connection(port: 8060)
-
-      response = conn.post path
-      return response.success?
+      response = multipart_connection(port: 8060).post path
+      @logger.fatal("Failed Deeplinking") unless response.success?
     end
 
     # List currently installed apps
     # @param logger [Logger] System Logger
-    def list()
+    def applist(options:)
       path = "/query/apps"
       conn = multipart_connection(port: 8060)
       response = conn.get path
@@ -58,4 +83,5 @@ module RokuBuilder
       params.collect{|k,v| "#{k}=#{CGI.escape(v)}"}.join('&')
     end
   end
+  RokuBuilder.register_plugin(Linker)
 end

data/lib/roku_builder/plugins/loader.rb

@@ -0,0 +1,152 @@
+# ********** Copyright Viacom, Inc. Apache 2.0 **********
+
+module RokuBuilder
+
+  # Load/Unload/Build roku applications
+  class Loader < Util
+    extend Plugin
+
+    def self.commands
+      {
+        sideload: {source: true, device: true, stage: true},
+        build: {source: true, stage: true, exclude: true},
+        delete: {device: true}
+      }
+    end
+
+    def self.parse_options(parser:, options:)
+      parser.separator "Commands:"
+      parser.on("-l", "--sideload", "Sideload an app") do
+        options[:sideload] = true
+      end
+      parser.on("-d", "--delete", "Delete the currently sideloaded app") do
+        options[:delete] = true
+      end
+      parser.on("-b", "--build", "Build a zip to be sideloaded") do
+        options[:build] = true
+      end
+      parser.separator "Options:"
+      parser.on("-x", "--exclude", "Apply exclude config to sideload") do
+        options[:exclude] = true
+      end
+    end
+
+    def self.dependencies
+      [Navigator]
+    end
+
+    # Sideload an app onto a roku device
+    def sideload(options:)
+      Navigator.new(config: @config).nav(options:{nav: "home"})
+      did_build = false
+      unless options[:in]
+        did_build = true
+        build(options: options)
+      end
+      upload
+      # Cleanup
+      File.delete(file_path(:in)) if did_build and not options[:out]
+    end
+
+
+    # Build an app to sideload later
+    def build(options:)
+      @options = options
+      build_zip(setup_build_content)
+      @config.in = @config.out #setting in path for possible sideload
+    end
+
+    # Remove the currently sideloaded app
+    def delete(options:)
+      payload =  {mysubmit: "Delete", archive: ""}
+      response  = multipart_connection.post "/plugin_install", payload
+      unless response.status == 200 and response.body =~ /Delete Succeeded/
+        raise ExecutionError, "Failed Unloading"
+      end
+    end
+
+    private
+
+    def upload
+      payload =  {
+        mysubmit: "Replace",
+        archive: Faraday::UploadIO.new(file_path(:in), 'application/zip')
+      }
+      response = multipart_connection.post "/plugin_install", payload
+      if response.status==200 and response.body=~/Identical to previous version/
+        @logger.warn("Sideload identival to previous version")
+      elsif not (response.status==200 and response.body=~/Install Success/)
+        @logger.debug("Status: #{response.status}, Body: #{response.body}")
+        raise ExecutionError, "Failed Sideloading"
+      end
+    end
+
+    def file_path(type)
+      file = @config.send(type)[:file]
+      file ||= Manifest.new(config: @config).build_version
+      file = file+".zip" unless file.end_with?(".zip")
+      File.join(@config.send(type)[:folder], file)
+    end
+
+    def setup_build_content()
+      content = {}
+      content[:excludes] = []
+      if @options[:current]
+        content[:folders] = Dir.entries(@config.root_dir).select {|entry| File.directory? File.join(@config.root_dir, entry) and !(entry =='.' || entry == '..') }
+        content[:files] = Dir.entries(@config.root_dir).select {|entry| File.file? File.join(@config.root_dir, entry)}
+      else
+        content[:folders] = @config.project[:folders]
+        content[:files] = @config.project[:files]
+        content[:exclude] if @options[:exclude] or @options.exclude_command?
+      end
+      content
+    end
+
+    def build_zip(content)
+      path = file_path(:out)
+      File.delete(path) if File.exist?(path)
+      io = Zip::File.open(path, Zip::File::CREATE)
+      # Add folders to zip
+      content[:folders].each do |folder|
+        base_folder = File.join(@config.root_dir, folder)
+        if File.exist?(base_folder)
+          entries = Dir.entries(base_folder)
+          entries.delete(".")
+          entries.delete("..")
+          writeEntries(@config.root_dir, entries, folder, content[:excludes], io)
+        else
+          @logger.warn "Missing Folder: #{base_folder}"
+        end
+      end
+      # Add file to zip
+      writeEntries(@config.parsed[:root_dir], content[:files], "", content[:excludes], io)
+      io.close()
+    end
+
+    # 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
+  RokuBuilder.register_plugin(Loader)
+end

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

@@ -4,25 +4,35 @@ module RokuBuilder
 
   # Monitor development Logs
   class Monitor < Util
+    extend Plugin
+
+    def self.commands
+      { monitor: {device: true}}
+    end
+
+    def self.parse_options(parser:, options:)
+      parser.separator "Commands:"
+      parser.on("-m", "--monitor [TYPE]", "Run telnet to monitor roku log") do |m|
+        options[:monitor] = m || "main"
+      end
+      parser.separator "Options:"
+      parser.on("-R", "--regexp REGEXP", "A regular expression used to filter monitor logs") do |r|
+        options[:regexp] = r
+      end
+    end
 
     # Initialize port config
     def init()
       @ports = {
         main: 8085,
-        sg: 8089,
-        task1: 8090,
-        task2: 8091,
-        task3: 8092,
-        taskX: 8093,
         profiler: 8080,
       }
       @show_prompt = false
     end
 
     # Monitor a development log on the Roku device
-    # @param type [Symbol] The log type to monitor
-    # @param regexp [Regexp] regular expression to filter text on
-    def monitor(type:, regexp: nil)
+    def monitor(options:)
+      type = options[:monitor].to_sym
       telnet_config = { 'Host' => @roku_ip_address, 'Port' => @ports[type] }
       waitfor_config = { 'Match' => /./, 'Timeout' => false }
 
@@ -33,7 +43,7 @@ module RokuBuilder
         all_text = ""
         while true
           connection.waitfor(waitfor) do |txt|
-            all_text = manage_text(all_text: all_text, txt: txt, regexp: regexp)
+            all_text = manage_text(all_text: all_text, txt: txt, regexp: options[:regexp])
           end
         end
       }
@@ -118,4 +128,5 @@ module RokuBuilder
       all_text
     end
   end
+  RokuBuilder.register_plugin(Monitor)
 end

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

@@ -4,9 +4,39 @@ module RokuBuilder
 
   # Navigation methods
   class Navigator < Util
+    extend Plugin
+
+    def self.commands
+      {
+        nav: {device: true},
+        navigate: {device: true},
+        type: {device: true},
+        screen: {device: true},
+        screens: {}
+      }
+    end
+
+    def self.parse_options(parser:, options:)
+      parser.separator("Commands:")
+      parser.on("-N", "--nav CMD", "Send the given command to the roku") do |n|
+        options[:nav] = n
+      end
+      parser.on("--navigate", "Run interactive navigator") do
+        options[:navigate] = true
+      end
+      parser.on("-y", "--type TEXT", "Type the given text on the roku device") do |t|
+        options[:type] = t
+      end
+      parser.on("--screen SCREEN", "Show a screen") do |s|
+        options[:screen] = s
+      end
+      parser.on("--screens", "Show possible screens") do
+        options[:screens] = true
+      end
+    end
 
     # Setup navigation commands
-    def init(mappings: nil)
+    def init()
       @commands = {
         home: "Home",             rew: "Rev",                 ff: "Fwd",
         play: "Play",             select: "Select",           left: "Left",
@@ -33,67 +63,33 @@ module RokuBuilder
       @runable = [
         :secret, :channels
       ]
-      mappings_init(mappings: mappings)
+      mappings_init
     end
 
-    # Init Mappings
-    def mappings_init(mappings: nil)
-      @mappings = {
-        "\e[1~": [ "home", "Home" ],
-        "<": [ "rew", "<" ],
-        ">": [ "ff", ">" ],
-        "=": [ "play", "=" ],
-        "\r": [ "select", "Enter" ],
-        "\e[D": [ "left", "Left Arrow" ],
-        "\e[C": [ "right", "Right Arrow" ],
-        "\e[B": [ "down", "Down Arrow" ],
-        "\e[A": [ "up", "Up Arrow" ],
-        "\t": [ "back", "Tab" ],
-        #"": [ "replay", "" ],
-        "*": [ "info", "*" ],
-        "\u007f": [ "backspace", "Backspace" ],
-        "?": [ "search", "?" ],
-        "\e\r": [ "enter", "Alt + Enter" ],
-        "\e[5~": [ "volumeup", "Page Up" ],
-        "\e[6~": [ "volumedown", "Page Down" ],
-        "\e[4~": [ "mute", "End" ],
-        #"": [ "channeldown", "" ],
-        #"": [ "channelup", "" ],
-        #"": [ "tuner", "" ],
-        #"": [ "hdmi1", "" ],
-        #"": [ "hdmi2", "" ],
-        #"": [ "hdmi3", "" ],
-        #"": [ "hdmi4", "" ],
-        #"": [ "avi", "" ]
-      }
-      @mappings.merge!(mappings) if mappings
-    end
 
     # Send a navigation command to the roku device
     # @param command [Symbol] The smbol of the command to send
     # @return [Boolean] Success
-    def nav(commands:)
+    def nav(options:)
+      commands = options[:nav].split(/, */).map{|c| c.to_sym}
       commands.each do |command|
-        if @commands.has_key?(command)
-          conn = multipart_connection(port: 8060)
-
-          path = "/keypress/#{@commands[command]}"
-          @logger.debug("Send Command: "+path)
-          response = conn.post path
-          return false unless response.success?
-        else
-          return false
+        unless @commands.has_key?(command)
+          raise ExecutionError, "Unknown Navigation Command"
         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
-      return true
     end
 
     # Type text on the roku device
     # @param text [String] The text to type on the device
     # @return [Boolean] Success
-    def type(text:)
+    def type(options:)
       conn = multipart_connection(port: 8060)
-      text.split(//).each do |c|
+      options[:type].split(//).each do |c|
         path = "/keypress/LIT_#{CGI::escape(c)}"
         @logger.debug("Send Letter: "+path)
         response = conn.post path
@@ -102,7 +98,7 @@ module RokuBuilder
       return true
     end
 
-    def interactive
+    def navigate(options:)
       running = true
       @logger.info("Key Mappings:")
       @mappings.each_value {|key|
@@ -115,64 +111,83 @@ module RokuBuilder
         if char == "\u0003"
           running = false
         else
-          Thread.new(char) {|character|
-            if @mappings[character.to_sym] != nil
-              nav(commands:[@mappings[character.to_sym][0].to_sym])
-            elsif character.inspect.force_encoding("UTF-8").ascii_only?
-              type(text: character)
-            end
-          }
+          Thread.new(char) {|character| handle_navigate_input(character)}
         end
       end
     end
 
+
     # Show the commands for one of the roku secret screens
     # @param type [Symbol] The type of screen to show
     # @return [Boolean] Screen found
-    def screen(type:)
-      if @screens.has_key?(type)
-        if @runable.include?(type)
-          nav(commands: @screens[type])
-        else
-          @logger.unknown("Cannot run command automatically")
-        end
-        display, count, string = [], [], ""
-        @screens[type].each do |command|
-          if display.count > 0 and  display[-1] == command
-            count[-1] = count[-1] + 1
-          else
-            display.push(command)
-            count.push(1)
-          end
-        end
-        display.each_index do |i|
-          if count[i] > 1
-            string = string + @commands[display[i]]+" x "+count[i].to_s+", "
-          else
-            string = string + @commands[display[i]]+", "
-          end
-        end
-        if @runable.include?(type)
-          @logger.info(string.strip)
-        else
-          @logger.unknown(string.strip)
-        end
+    def screen(options:)
+      type = options[:screen].to_sym
+      unless @screens.has_key?(type)
+        raise ExecutionError, "Unknown Screen"
+      end
+      if @runable.include?(type)
+        nav(options: {nav: @screens[type].join(", ")})
       else
-        return false
+        @logger.unknown("Cannot run command automatically")
       end
-      true
+      display_screen_command(type)
     end
 
     # Show avaiable roku secret screens
-    def screens
+    def screens(options:)
       @screens.keys.each {|screen| @logger.unknown(screen)}
     end
 
+    private
+
+    def mappings_init()
+      @mappings = {
+        "\e[1~": [ "home", "Home" ],
+        "<": [ "rew", "<" ],
+        ">": [ "ff", ">" ],
+        "=": [ "play", "=" ],
+        "\r": [ "select", "Enter" ],
+        "\e[D": [ "left", "Left Arrow" ],
+        "\e[C": [ "right", "Right Arrow" ],
+        "\e[B": [ "down", "Down Arrow" ],
+        "\e[A": [ "up", "Up Arrow" ],
+        "\t": [ "back", "Tab" ],
+        #"": [ "replay", "" ],
+        "*": [ "info", "*" ],
+        "\u007f": [ "backspace", "Backspace" ],
+        "?": [ "search", "?" ],
+        "\e\r": [ "enter", "Alt + Enter" ],
+        "\e[5~": [ "volumeup", "Page Up" ],
+        "\e[6~": [ "volumedown", "Page Down" ],
+        "\e[4~": [ "mute", "End" ],
+        #"": [ "channeldown", "" ],
+        #"": [ "channelup", "" ],
+        #"": [ "tuner", "" ],
+        #"": [ "hdmi1", "" ],
+        #"": [ "hdmi2", "" ],
+        #"": [ "hdmi3", "" ],
+        #"": [ "hdmi4", "" ],
+        #"": [ "avi", "" ]
+      }
+      @mappings.merge!(generate_maggings) if @config.input_mappings
+    end
+
+    def generate_maggings
+      mappings = {}
+      if @config.input_mappings
+        @config.input_mappings.each_pair {|key, value|
+          unless "".to_sym == key
+            key = key.to_s.sub(/\\e/, "\e").to_sym
+            mappings[key] = value
+          end
+        }
+      end
+      mappings
+    end
+
     def read_char
       STDIN.echo = false
       STDIN.raw!
-
-
       input = STDIN.getc.chr
       if input == "\e" then
         input << STDIN.read_nonblock(3) rescue nil
@@ -183,5 +198,38 @@ module RokuBuilder
       STDIN.echo = true
       STDIN.cooked!
     end
+
+    def handle_navigate_input(char)
+      if @mappings[char.to_sym] != nil
+        nav(options: {nav: @mappings[char.to_sym][0]})
+      elsif char.inspect.force_encoding("UTF-8").ascii_only?
+        type(options: {type: char})
+      end
+    end
+
+    def display_screen_command(type)
+      display, count, string = [], [], ""
+      @screens[type].each do |command|
+        if display.count > 0 and  display[-1] == command
+          count[-1] = count[-1] + 1
+        else
+          display.push(command)
+          count.push(1)
+        end
+      end
+      display.each_index do |i|
+        if count[i] > 1
+          string = string + @commands[display[i]]+" x "+count[i].to_s+", "
+        else
+          string = string + @commands[display[i]]+", "
+        end
+      end
+      if @runable.include?(type)
+        @logger.info(string.strip)
+      else
+        @logger.unknown(string.strip)
+      end
+    end
   end
+  RokuBuilder.register_plugin(Navigator)
 end