roku_builder 3.13.0 → 4.0.0

data/lib/roku_builder/controller_commands.rb

@@ -1,224 +0,0 @@
-# ********** Copyright Viacom, Inc. Apache 2.0 **********
-
-module RokuBuilder
-
-  # Commands that the controller uses to interface with the rest of the gem.
-  class ControllerCommands
-
-    # Provides a hash of all of the options needed to run simple commands via
-    # the simple_command method
-    # @return [Hash] options to run simple commands
-    def self.simple_commands
-      {
-        delete: { klass: Loader, method: :unload },
-        monitor: { klass: Monitor, method: :monitor,
-          config_key: :monitor_config },
-        navigate: { klass: Navigator, method: :nav, config_key: :navigate_config,
-          failure: FAILED_NAVIGATING },
-        navigator: { klass: Navigator, method: :interactive },
-        screen: { klass: Navigator, method: :screen, config_key: :screen_config,
-          failure: FAILED_NAVIGATING },
-        key: { klass: Keyer, method: :rekey, config_key: :key },
-        genkey: { klass: Keyer, method: :genkey, config_key: :genkey },
-        screens: { klass: Navigator, method: :screens },
-        text: { klass: Navigator, method: :type, config_key: :text_config },
-        screencapture: { klass: Inspector, method: :screencapture, config_key: :screencapture_config,
-          failure: FAILED_SCREENCAPTURE },
-        applist: {klass: Linker, method: :list},
-        profile: {klass: Profiler, method: :run, config_key: :profiler_config}
-      }
-    end
-    # Validate Config
-    # @return [Integer] Success or Failure Code
-    def self.validate()
-      Logger.instance.info "Config validated"
-      SUCCESS
-    end
-    # Run Sideload
-    # @param options [Hash] user options
-    # @param config [Config] parsed config
-    # @return [Integer] Success or Failure Code
-    def self.sideload(options:, config:)
-      device_config = config.parsed[:device_config].dup
-      device_config[:init_params] = config.parsed[:init_params][:loader]
-      stager = Stager.new(**config.parsed[:stage_config])
-      success = nil
-      if stager.stage
-        loader = Loader.new(**device_config)
-        build_version = ManifestManager.build_version(**config.parsed[:manifest_config])
-        options[:build_version] = build_version
-        config.update
-        success = loader.sideload(**config.parsed[:sideload_config])[0]
-      end
-      stager.unstage
-      if success == SUCCESS
-        Logger.instance.info "App Sideloaded; staged using #{stager.method}"
-      end
-      success
-    end
-    # Run Package
-    # @param options [Hash] user options
-    # @param config [Conifg] config object
-    # @return [Integer] Success or Failure Code
-    def self.package(options:, config:)
-      loader_config = config.parsed[:device_config].dup
-      loader_config[:init_params] = config.parsed[:init_params][:loader]
-      keyer = Keyer.new(**config.parsed[:device_config])
-      stager = Stager.new(**config.parsed[:stage_config])
-      loader = Loader.new(**loader_config)
-      packager = Packager.new(**config.parsed[:device_config])
-      Logger.instance.warn "Packaging working directory" if options[:working]
-      if stager.stage
-        # Sideload #
-        code, build_version = loader.sideload(**config.parsed[:sideload_config])
-        return code unless code == SUCCESS
-        # Key #
-        _success = keyer.rekey(**config.parsed[:key])
-        # Package #
-        options[:build_version] = build_version
-        config.update
-        success = packager.package(**config.parsed[:package_config])
-        Logger.instance.info "Signing Successful: #{config.parsed[:package_config][:out_file]}" if success
-        return FAILED_SIGNING unless success
-        # Inspect #
-        if options[:inspect]
-          inspect_package(config: config)
-        end
-      end
-      stager.unstage
-      Logger.instance.info "App Packaged; staged using #{stager.method}"
-      SUCCESS
-    end
-    # Run Sideload
-    # @param options [Hash] user options
-    # @param config [Config] parsed config
-    # @return [Integer] Success or Failure Code
-    def self.test(options:, config:)
-      device_config = config.parsed[:device_config].dup
-      device_config[:init_params] = config.parsed[:init_params][:tester]
-      stager = Stager.new(**config.parsed[:stage_config])
-      if stager.stage
-        tester = Tester.new(**device_config)
-        tester.run_tests(**config.parsed[:test_config])
-      end
-      stager.unstage
-      SUCCESS
-    end
-
-    def self.inspect_package(config:)
-      inspector = Inspector.new(**config.parsed[:device_config])
-      info = inspector.inspect(config.parsed[:inspect_config])
-      inspect_logger = ::Logger.new(STDOUT)
-      inspect_logger.formatter = proc {|_severity, _datetime, _progname, msg|
-        "%s\n\r" % [msg]
-      }
-      inspect_logger.unknown "=============================================================="
-      inspect_logger.unknown "App Name: #{info[:app_name]}"
-      inspect_logger.unknown "Dev ID: #{info[:dev_id]}"
-      inspect_logger.unknown "Creation Date: #{info[:creation_date]}"
-      inspect_logger.unknown "dev.zip: #{info[:dev_zip]}"
-      inspect_logger.unknown "=============================================================="
-    end
-    private_class_method :inspect_package
-
-    # Run Build
-    # @param options [Hash] user options
-    # @param config [Config] config object
-    # @return [Integer] Success or Failure Code
-    def self.build(options:, config:)
-      ### Build ###
-      loader_config = config.parsed[:device_config].dup
-      loader_config[:init_params] = config.parsed[:init_params][:loader]
-      stager = Stager.new(**config.parsed[:stage_config])
-      loader = Loader.new(**loader_config)
-      if stager.stage
-        build_version = ManifestManager.build_version(**config.parsed[:manifest_config])
-        options[:build_version] = build_version
-        config.update
-        outfile = loader.build(**config.parsed[:build_config])
-        Logger.instance.info "Build: #{outfile}"
-      end
-      stager.unstage
-      Logger.instance.info "App build; staged using #{stager.method}"
-      SUCCESS
-    end
-    # Run update
-    # @param config [Config] config object
-    # @return [Integer] Success or Failure Code
-    def self.update(config:)
-      ### Update ###
-      stager = Stager.new(**config.parsed[:stage_config])
-      if stager.stage
-        old_version = ManifestManager.build_version(**config.parsed[:manifest_config])
-        new_version = ManifestManager.update_build(**config.parsed[:manifest_config])
-        Logger.instance.info "Update build version from:\n#{old_version}\nto:\n#{new_version}"
-      end
-      stager.unstage
-      SUCCESS
-    end
-
-    # Run Deeplink
-    # @param options [Hash] user options
-    # @param config [Config] config object
-    def self.deeplink(options:, config:)
-      if options.has_source?
-        sideload(options: options, config: config)
-      end
-
-      linker = Linker.new(config.parsed[:device_config])
-      if linker.launch(config.parsed[:deeplink_config])
-        Logger.instance.info "Deeplinked into app"
-        return SUCCESS
-      else
-        return FAILED_DEEPLINKING
-      end
-    end
-
-    # Run Print
-    # @param options [Hash] user options
-    # @param config [Config] config object
-    def self.print(options:, config:)
-      stager = Stager.new(**config.parsed[:stage_config])
-      code = nil
-      if stager.stage
-        code = Scripter.print(attribute: options[:print].to_sym, configs: config.parsed)
-      end
-      stager.unstage
-      code
-    end
-
-    def self.dostage(config:)
-      stager = Stager.new(**config.parsed[:stage_config])
-      stager.stage
-    end
-
-    def self.dounstage(config:)
-      stager = Stager.new(**config.parsed[:stage_config])
-      stager.unstage
-    end
-
-    # Run a simple command
-    # @param klass [Class] class of object to create
-    # @param method [Symbol] methog to run on klass
-    # @param config_key [Symbol] config to send from configs if not nil
-    # @param config [Configs] config object
-    # @param failure [Integer] failure code to return on failure if not nil
-    # @return [Integer] Success of failure code
-    def self.simple_command(klass:, method:, config_key: nil, config:, failure: nil)
-      klass_config = config.parsed[:device_config].dup
-      key = klass.to_s.split("::")[-1].underscore.to_sym
-      if config.parsed[:init_params][key]
-        klass_config[:init_params] = config.parsed[:init_params][key]
-      end
-      instance = klass.new(**klass_config)
-      if config_key
-        success = instance.send(method, config.parsed[config_key])
-      else
-        success = instance.send(method)
-      end
-      return failure unless failure.nil? or success
-      Logger.instance.debug "#{klass} call #{method} successfully"
-      SUCCESS
-    end
-  end
-end

data/lib/roku_builder/error_handler.rb

@@ -1,142 +0,0 @@
-# ********** Copyright Viacom, Inc. Apache 2.0 **********
-
-module RokuBuilder
-
-  # Contains methods to handle errors from different sources.
-  class ErrorHandler
-    # Handle codes returned from validating options
-    # @param options_code [Integer] the error code returned by validate_options
-    # @param logger [Logger] system logger
-    def self.handle_options_codes(options_code:, options:, logger:)
-      case options_code
-      when EXTRA_COMMANDS
-        logger.fatal "Only one command is allowed"
-        abort
-      when NO_COMMANDS
-        logger.fatal "At least one command is required"
-        abort
-      when EXTRA_SOURCES
-        logger.fatal "Only use one of --ref, --working, --current or --stage"
-        abort
-      when NO_SOURCE
-        logger.fatal "Must use at least one of --ref, --working, --current or --stage"
-        abort
-      when BAD_CURRENT
-        logger.fatal "Can only sideload or build 'current' directory"
-        abort
-      when BAD_IN_FILE
-        logger.fatal "Can only supply in file for building"
-        abort
-      when DEPRICATED
-        print_options_depricateions(options: options, logger: logger)
-      end
-    end
-
-    # Handle codes returned from configuring
-    # @param configure_code [Integer] the error code returned by configure
-    # @param logger [Logger] system logger
-    def self.handle_configure_codes(configure_code:, logger:)
-      case configure_code
-      when CONFIG_OVERWRITE
-        logger.fatal 'Config already exists. To create default please remove config first.'
-        abort
-      when SUCCESS
-        logger.info 'Configure successful'
-        abort
-      end
-    end
-
-    # Handle codes returned from load_config
-    # @param options [Hash] the options hash
-    # @param load_code [Integer] the error code returned by configure
-    # @param logger [Logger] system logger
-    def self.handle_load_codes(options:, load_code:, logger:)
-      case load_code
-      when DEPRICATED_CONFIG
-        logger.warn 'Depricated config. See Above'
-      when MISSING_CONFIG
-        logger.fatal "Missing config file: #{options[:config]}"
-        abort
-      when INVALID_CONFIG
-        logger.fatal 'Invalid config. See Above'
-        abort
-      when MISSING_MANIFEST
-        logger.fatal 'Manifest file missing'
-        abort
-      when UNKNOWN_DEVICE
-        logger.fatal "Unkown device id"
-        abort
-      when UNKNOWN_PROJECT
-        logger.fatal "Unknown project id"
-        abort
-      when UNKNOWN_STAGE
-        logger.fatal "Unknown stage"
-        abort
-      when BAD_PROJECT_DIR
-        logger.fatal "Invalid directory for project"
-        abort
-      when BAD_KEY_FILE
-        logger.fatal "Invalid key path"
-        abort
-      end
-    end
-
-    # Handle codes returned from configuring
-    # @param configure_code [Integer] the error code returned by configure
-    # @param logger [Logger] system logger
-    def self.handle_configs_codes(configs_code:, logger:)
-      case configs_code
-      when MISSING_OUT_FOLDER
-        logger.fatal 'The folder passed in the command line options does not exist.'
-        abort
-      when VALID
-        logger.debug 'Configs OK'
-      end
-    end
-
-    # Handle codes returned from checking devices
-    # @param device_code [Integer] the error code returned by check_devices
-    # @param logger [Logger] system logger
-    def self.handle_device_codes(device_code:, logger:)
-      case device_code
-      when CHANGED_DEVICE
-        logger.info "The default device was not online so a secondary device is being used"
-      when BAD_DEVICE
-        logger.fatal "The selected device was not online"
-        abort
-      when NO_DEVICES
-        logger.fatal "No configured devices were found"
-        abort
-      end
-    end
-
-    # Handle codes returned from handeling commands devices
-    # @param command_code [Integer] the error code returned by handle_options
-    # @param logger [Logger] system logger
-    def self.handle_command_codes(command_code:, logger:)
-      case command_code
-      when FAILED_SIDELOAD
-        logger.fatal "Failed Sideloading App"
-        abort
-      when FAILED_SIGNING
-        logger.fatal "Failed Signing App"
-        abort
-      when FAILED_DEEPLINKING
-        logger.fatal "Failed Deeplinking To App"
-        abort
-      when FAILED_NAVIGATING
-        logger.fatal "Command not sent"
-        abort
-      when FAILED_SCREENCAPTURE
-        logger.fatal "Failed to Capture Screen"
-        abort
-      when BAD_PRINT_ATTRIBUTE
-        logger.fatal "Unknown print attribute"
-        abort
-      when MISSING_MANIFEST
-        logger.fatal 'Manifest file missing'
-        abort
-      end
-    end
-  end
-end

data/lib/roku_builder/inspector.rb

@@ -1,82 +0,0 @@
-# ********** Copyright Viacom, Inc. Apache 2.0 **********
-
-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:)
-
-      pkg = pkg+".pkg" unless pkg.end_with?(".pkg")
-      # upload new key with password
-      path = "/plugin_inspect"
-      conn = multipart_connection
-      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 = /new Date\(([^)]*)\)/.match(response.body.delete("\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.delete("\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 = multipart_connection
-      payload =  {
-        mysubmit: "Screenshot",
-        passwd: @dev_password,
-        archive: Faraday::UploadIO.new(File::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_time = /time=([^"]*)">/.match(response.body)
-        out_ext = /dev.([^"]*)\?/.match(response.body)
-        out_file = "dev_#{out_time[1]}.#{out_ext[1]}" if out_time and out_ext
-        out_file = "dev.jpg" unless out_file
-      end
-
-      conn = simple_connection
-
-      response = conn.get path
-
-      File.open(File.join(out_folder, out_file), "wb") do |io|
-        io.write(response.body)
-      end
-      @logger.info "Screen captured to #{File.join(out_folder, out_file)}"
-      return response.success?
-    end
-  end
-end