roku_builder 3.3.2

data/lib/roku_builder/inspector.rb

@@ -0,0 +1,90 @@
+module RokuBuilder
+
+  # Collects information on a package for submission
+  class Inspector < Util
+
+    # Inspects the given pkg
+    # @param pkg [String] Path to the pkg to be inspected
+    # @param password [String] Password for the given pkg
+    # @return [Hash] Package information. Contains the following keys:
+    #   * app_name
+    #   * dev_id
+    #   * creation_date
+    #   * dev_zip
+    def inspect(pkg:, password:)
+
+      # upload new key with password
+      path = "/plugin_inspect"
+      conn = Faraday.new(url: @url) do |f|
+        f.request :digest, @dev_username, @dev_password
+        f.request :multipart
+        f.request :url_encoded
+        f.adapter Faraday.default_adapter
+      end
+      payload =  {
+        mysubmit: "Inspect",
+        passwd: password,
+        archive: Faraday::UploadIO.new(pkg, 'application/octet-stream')
+      }
+      response = conn.post path, payload
+
+      app_name = /App Name:\s*<\/td>\s*<td>\s*<font[^>]*>([^<]*)<\/font>\s*<\/td>/.match(response.body)
+      dev_id = nil
+      creation_date = nil
+      dev_zip = nil
+      if app_name
+        app_name = app_name[1]
+        dev_id = /Dev ID:\s*<\/td>\s*<td>\s*<font[^>]*>([^<]*)<\/font>\s*<\/td>/.match(response.body)[1]
+        creation_date = /Creation Date:\s*<\/td>\s*<td>\s*<font[^>]*>\s*<script[^>]*>\s*var d = new Date\(([^\)]*)\)[^<]*<\/script><\/font>\s*<\/td>/.match(response.body.gsub("\n", ''))[1]
+        dev_zip = /dev.zip:\s*<\/td>\s*<td>\s*<font[^>]*>([^<]*)<\/font>\s*<\/td>/.match(response.body)[1]
+      else
+        app_name = /App Name:[^<]*<div[^>]*>([^<]*)<\/div>/.match(response.body)[1]
+        dev_id = /Dev ID:[^<]*<div[^>]*><font[^>]*>([^<]*)<\/font><\/div>/.match(response.body)[1]
+        creation_date = /new Date\(([^\/]*)\)/.match(response.body.gsub("\n", ''))[1]
+        dev_zip = /dev.zip:[^<]*<div[^>]*><font[^>]*>([^<]*)<\/font><\/div>/.match(response.body)[1]
+      end
+
+      return {app_name: app_name, dev_id: dev_id, creation_date: Time.at(creation_date.to_i).to_s, dev_zip: dev_zip}
+
+    end
+
+    # Capture a screencapture for the currently sideloaded app
+    # @return [Boolean] Success
+    def screencapture(out_folder:, out_file: nil)
+      path = "/plugin_inspect"
+      conn = Faraday.new(url: @url) do |f|
+        f.request :digest, @dev_username, @dev_password
+        f.request :multipart
+        f.request :url_encoded
+        f.adapter Faraday.default_adapter
+      end
+      payload =  {
+        mysubmit: "Screenshot",
+        passwd: @dev_password,
+        archive: Faraday::UploadIO.new("/dev/null", 'application/octet-stream')
+      }
+      response = conn.post path, payload
+
+      path = /<img src="([^"]*)">/.match(response.body)
+      return false unless path
+      path = path[1]
+      unless out_file
+        out_file = /time=([^"]*)">/.match(response.body)
+        out_file = "dev_#{out_file[1]}.jpg" if out_file
+      end
+
+      conn = Faraday.new(url: @url) do |f|
+        f.request :digest, @dev_username, @dev_password
+        f.adapter Faraday.default_adapter
+      end
+
+      response = conn.get path
+
+      File.open(File.join(out_folder, out_file), "w") do |io|
+        io.write(response.body)
+      end
+      @logger.info "Screen captured to #{File.join(out_folder, out_file)}"
+      return response.success?
+    end
+  end
+end

data/lib/roku_builder/keyer.rb

@@ -0,0 +1,52 @@
+module RokuBuilder
+
+  # Change or get dev key
+  class Keyer < Util
+
+    # 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 = Faraday.new(url: @url) do |f|
+        f.request :digest, @dev_username, @dev_password
+        f.request :multipart
+        f.request :url_encoded
+        f.adapter Faraday.default_adapter
+      end
+      payload =  {
+        mysubmit: "Rekey",
+        passwd: password,
+        archive: Faraday::UploadIO.new(keyed_pkg, 'application/octet-stream')
+      }
+      response = conn.post path, payload
+
+      # check key
+      newId = dev_id
+      newId != oldId
+    end
+
+    # Get the current dev id
+    # @return [String] The current dev id
+    def dev_id
+      path = "/plugin_package"
+      conn = Faraday.new(url: @url) do |f|
+        f.request :digest, @dev_username, @dev_password
+        f.adapter Faraday.default_adapter
+      end
+      response = conn.get path
+
+      dev_id = /Your Dev ID:\s*<font[^>]*>([^<]*)<\/font>/.match(response.body)
+      if dev_id
+        dev_id = dev_id[1]
+      else
+        dev_id = /Your Dev ID:[^>]*<\/label> ([^<]*)/.match(response.body)[1]
+      end
+      dev_id
+    end
+  end
+end

data/lib/roku_builder/linker.rb

@@ -0,0 +1,46 @@
+module RokuBuilder
+
+  # Launch application, sending parameters
+  class Linker < Util
+    # Deeplink to the currently sideloaded app
+    # @param options [String] Options string
+    # @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 link(options:)
+      path = "/launch/dev"
+      payload = {}
+      return false unless options
+      opts = options.split(/,\s*/)
+      opts.each do |opt|
+        opt = opt.split(":")
+        key = opt.shift.to_sym
+        value = opt.join(":")
+        payload[key] = value
+      end
+
+      unless payload.keys.count > 0
+        return false
+      end
+
+      path = "#{path}?#{parameterize(payload)}"
+      conn = Faraday.new(url: "#{@url}:8060") do |f|
+        f.request :digest, @dev_username, @dev_password
+        f.request :multipart
+        f.request :url_encoded
+        f.adapter Faraday.default_adapter
+      end
+
+      response = conn.post path
+      return response.success?
+    end
+
+    private
+
+    # Parameterize options to be sent to the app
+    # @param params [Hash] Parameters to be sent
+    # @return [String] Parameters as a string, URI escaped
+    def parameterize(params)
+      URI.escape(params.collect{|k,v| "#{k}=#{URI.escape(v, "?&")}"}.join('&'))
+    end
+  end
+end

data/lib/roku_builder/loader.rb

@@ -0,0 +1,197 @@
+module RokuBuilder
+
+  # Load/Unload/Build roku applications
+  class Loader < Util
+
+    # Sideload an app onto a roku device
+    # @param root_dir [String] Path to the root directory of the roku app
+    # @param branch [String] Branch of the git repository to sideload. Pass nil to use working directory. Default: nil
+    # @param update_manifest [Boolean] Flag to update the manifest file before sideloading. Default: false
+    # @param fetch [Boolean] Flag to fetch all remotes before sideloading. Default: false
+    # @param folders [Array<String>] Array of folders to be sideloaded. Pass nil to send all folders. Default: nil
+    # @param files [Array<String>] Array of files to be sideloaded. Pass nil to send all files. Default: nil
+    # @return [String] Build version on success, nil otherwise
+    def sideload(root_dir:, branch: nil, update_manifest: false, fetch: false, folders: nil, files: nil)
+      @root_dir = root_dir
+      result = nil
+      stash = nil
+      if branch
+        git = Git.open(@root_dir)
+        if fetch
+          for remote in git.remotes
+            git.fetch(remote)
+          end
+        end
+      end
+      current_dir = Dir.pwd
+      begin
+        if git and branch and branch != git.current_branch
+          Dir.chdir(@root_dir)
+          current_branch = git.current_branch
+          stash = git.branch.stashes.save("roku-builder-temp-stash")
+          git.checkout(branch)
+        end
+
+        # Update manifest
+        build_version = ""
+        if update_manifest
+          build_version = ManifestManager.update_build(root_dir: root_dir, logger: @logger)
+        else
+          build_version = ManifestManager.build_version(root_dir: root_dir, logger: @logger)
+        end
+
+        outfile = build(root_dir: root_dir, branch: branch, build_version: build_version, folders: folders, files: files)
+
+        path = "/plugin_install"
+
+        # Connect to roku and upload file
+        conn = Faraday.new(url: @url) do |f|
+          f.request :digest, @dev_username, @dev_password
+          f.request :multipart
+          f.request :url_encoded
+          f.adapter Faraday.default_adapter
+        end
+        payload =  {
+          mysubmit: "Replace",
+          archive: Faraday::UploadIO.new(outfile, 'application/zip')
+        }
+        response = conn.post path, payload
+
+        # Cleanup
+        File.delete(outfile)
+
+        if git and current_branch
+          git.checkout(current_branch)
+          git.branch.stashes.apply if stash
+        end
+
+        if response.status == 200 and response.body =~ /Install Success/
+          result = build_version
+        end
+
+      rescue Git::GitExecuteError => e
+        @logger.error "Branch or ref does not exist"
+        @logger.error e.message
+        @logger.error e.backtrace
+      ensure
+        Dir.chdir(current_dir) unless current_dir == Dir.pwd
+      end
+      result
+    end
+
+
+    # Build an app to sideload later
+    # @param root_dir [String] Path to the root directory of the roku app
+    # @param branch [String] Branch of the git repository to sideload. Pass nil to use working directory. Default: nil
+    # @param build_version [String] Version to assigne to the build. If nil will pull the build version form the manifest. Default: nil
+    # @param outfile [String] Path for the output file. If nil will create a file in /tmp. Default: nil
+    # @param fetch [Boolean] Flag to fetch all remotes before sideloading. Default: false
+    # @param folders [Array<String>] Array of folders to be sideloaded. Pass nil to send all folders. Default: nil
+    # @param files [Array<String>] Array of files to be sideloaded. Pass nil to send all files. Default: nil
+    # @return [String] Path of the build
+    def build(root_dir:, branch: nil, build_version: nil, outfile: nil, fetch: false, folders: nil, files: nil)
+      @root_dir = root_dir
+      result = nil
+      stash = nil
+      if branch
+        git = Git.open(@root_dir)
+        if fetch
+          for remote in git.remotes
+            git.fetch(remote)
+          end
+        end
+      end
+      current_dir = Dir.pwd
+      begin
+        if git and branch and branch != git.current_branch
+          Dir.chdir(@root_dir)
+          current_branch = git.current_branch
+          stash = git.branch.stashes.save("roku-builder-temp-stash")
+          git.checkout(branch)
+        end
+
+        build_version = ManifestManager.build_version(root_dir: root_dir, logger: @logger) unless build_version
+        unless folders
+          folders = Dir.entries(root_dir).select {|entry| File.directory? File.join(root_dir, entry) and !(entry =='.' || entry == '..') }
+        end
+        unless files
+          files = Dir.entries(root_dir).select {|entry| File.file? File.join(root_dir, entry)}
+        end
+        outfile = "/tmp/build_#{build_version}.zip" unless outfile
+
+        File.delete(outfile) if File.exists?(outfile)
+        io = Zip::File.open(outfile, Zip::File::CREATE)
+
+        # Add folders to zip
+        folders.each do |folder|
+          base_folder = File.join(@root_dir, folder)
+          entries = Dir.entries(base_folder)
+          entries.delete(".")
+          entries.delete("..")
+          writeEntries(@root_dir, entries, folder, io)
+        end
+
+        # Add file to zip
+        writeEntries(@root_dir, files, "", io)
+
+        io.close()
+
+        if git and current_branch
+          git.checkout(current_branch)
+          git.branch.stashes.apply if stash
+        end
+      rescue Git::GitExecuteError => e
+        @logger.error "Branch or ref does not exist"
+        @logger.error e.message
+        @logger.error e.backtrace
+      ensure
+        Dir.chdir(current_dir) unless current_dir == Dir.pwd
+      end
+      outfile
+    end
+
+    # Remove the currently sideloaded app
+    def unload()
+        path = "/plugin_install"
+
+        # Connect to roku and upload file
+        conn = 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
+        end
+        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, 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, io)
+        else
+          io.get_output_stream(zipFilePath) { |f| f.puts(File.open(diskFilePath, "rb").read()) }
+        end
+      }
+    end
+  end
+end

data/lib/roku_builder/manifest_manager.rb

@@ -0,0 +1,63 @@
+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:, logger:)
+
+      build_version = ""
+
+      temp_file = Tempfile.new('manifest')
+      path = File.join(root_dir, 'manifest')
+      begin
+        File.open(path, 'r') do |file|
+          file.each_line do |line|
+            if line.include?("build_version")
+
+              #Update build version.
+              build_version = line.split(".")
+              iteration = 0
+              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
+                #Use current date.
+                build_version = Time.now.strftime("%m%d%y")+".1"
+              end
+              temp_file.puts "build_version=#{build_version}"
+            else
+              temp_file.puts line
+            end
+          end
+        end
+        temp_file.rewind
+        FileUtils.cp(temp_file.path, path)
+      ensure
+        temp_file.close
+        temp_file.unlink
+      end
+      build_version
+    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:, logger:)
+      path = File.join(root_dir, 'manifest')
+      build_version = ""
+      File.open(path, 'r') do |file|
+        file.each_line do |line|
+          if line.include?("build_version")
+            build_version = line.split("=")[1].chomp
+          end
+        end
+      end
+      build_version
+    end
+  end
+end