aspera-cli 4.24.2 → 4.25.0.pre2

data/lib/aspera/keychain/macos_security.rb

@@ -49,7 +49,7 @@ module Aspera
               options[:path] = uri.path unless ['', '/'].include?(uri.path)
               options[:port] = uri.port unless uri.port.eql?(443) && !url.include?(':443/')
             end
-            command_args = [command]
+            command_args = [SECURITY_UTILITY, command]
             options&.each do |k, v|
               Aspera.assert(supported.key?(k)){"unknown option: #{k}"}
               next if v.nil?
@@ -57,7 +57,7 @@ module Aspera
               command_args.push(v.shellescape) unless v.empty?
             end
             command_args.push(last_opt) unless last_opt.nil?
-            return Environment.secure_capture(exec: SECURITY_UTILITY, args: command_args)
+            return Environment.secure_execute(*command_args, mode: :capture)
           end
 
           def key_chains(output)

data/lib/aspera/log.rb

@@ -81,8 +81,9 @@ module Aspera
       # @param object [Hash, nil]       Data to dump
       # @param level  [Symbol]          Debug level
       # @param block  [Proc, nil]       Give computed object
-      def dump(name, object = nil, level: :debug)
+      def dump(name, object = nil, level: :debug, &block)
         return unless instance.logger.send(:"#{level}?")
+        Aspera.assert(object.nil? || block.nil?){'Use either object, or block, not both'}
         object = yield if block_given?
         instance.logger.send(level, obj_dump(name, object))
       end

data/lib/aspera/markdown.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Aspera
+  # Formatting for Markdown
+  class Markdown
+    # Matches: **bold**, `code`, or an HTML entity (&, ©, 💩)
+    FORMATS = /(?:\*\*(?<bold>[^*]+?)\*\*)|(?:`(?<code>[^`]+)`)|&(?<entity>(?:[A-Za-z][A-Za-z0-9]{1,31}|#\d{1,7}|#x[0-9A-Fa-f]{1,6}));/m
+    HTML_BREAK = '<br/>'
+
+    class << self
+      # Generate markdown from the provided 2D table
+      def table(table)
+        # get max width of each columns
+        col_widths = table.transpose.map do |col|
+          [col.flat_map{ |c| c.to_s.delete('`').split(HTML_BREAK).map(&:size)}.max, 80].min
+        end
+        headings = table.shift
+        table.unshift(col_widths.map{ |col_width| '-' * col_width})
+        table.unshift(headings)
+        lines = table.map{ |line| "| #{line.map{ |i| i.to_s.gsub('\\', '\\\\').gsub('|', '\|')}.join(' | ')} |\n"}
+        lines[1] = lines[1].tr(' ', '-')
+        return lines.join.chomp
+      end
+
+      # Generate markdown list from the provided list
+      def list(items)
+        items.map{ |i| "- #{i}"}.join("\n")
+      end
+    end
+  end
+end

data/lib/aspera/nagios.rb

@@ -21,7 +21,7 @@ module Aspera
     end
 
     class << self
-      # process results of a analysis and display status and exit with code
+      # Process results of a analysis and display status and exit with code
       def process(data)
         Aspera.assert_type(data, Array)
         Aspera.assert(!data.empty?){'data is empty'}
@@ -54,7 +54,7 @@ module Aspera
       @data = []
     end
 
-    # compare remote time with local time
+    # Compare remote time with local time
     def check_time_offset(remote_date, component)
       # check date if specified : 2015-10-13T07:32:01Z
       remote_time = Time.parse(remote_date)
@@ -76,10 +76,11 @@ module Aspera
       # TODO: check on database if latest version
     end
 
-    # translate for display
-    def result
+    # Readable status list
+    # @return [Array] of Hash
+    def status_list
       Aspera.assert(!@data.empty?){'missing result'}
-      {type: :object_list, data: @data.map{ |i| {'status' => LEVELS[i[:code]].to_s, 'component' => i[:comp], 'message' => i[:msg]}}}
+      @data.map{ |i| {'status' => LEVELS[i[:code]].to_s, 'component' => i[:comp], 'message' => i[:msg]}}
     end
   end
 end

data/lib/aspera/oauth/base.rb

@@ -59,25 +59,13 @@ module Aspera
 
       attr_reader :scope, :api, :path_token, :client_id
 
-      # helper method to create token as per RFC
+      # Helper method to create token as per RFC
+      # @return [HTTPResponse]
+      # @raise RestError if not 2XX code
       def create_token_call(creation_params)
         Log.log.debug{'Generating a new token'.bg_green}
-        payload = if @use_query
-          {
-            query: creation_params
-          }
-        else
-          {
-            content_type: Rest::MIME_WWW,
-            body:         creation_params
-          }
-        end
-        return @api.call(
-          operation: 'POST',
-          subpath:   @path_token,
-          headers:   {'Accept' => Rest::MIME_JSON},
-          **payload
-        )
+        return @api.create(@path_token, nil, query: creation_params, ret: :resp) if @use_query
+        return @api.create(@path_token, creation_params, content_type: Rest::MIME_WWW, ret: :resp)
       end
 
       # @param add_secret [Boolean] Add secret in default call parameters
@@ -122,17 +110,18 @@ module Aspera
             Factory.instance.persist_mgr.delete(@token_cache_id)
             token_data = nil
             # lets try the existing refresh token
+            # NOTE: AoC admin token has no refresh, and lives by default 1800secs
             if !refresh_token.nil?
-              Log.log.info{"refresh=[#{refresh_token}]".bg_green}
-              # NOTE: AoC admin token has no refresh, and lives by default 1800secs
-              resp = create_token_call(optional_scope_client_id(add_secret: true).merge(grant_type: 'refresh_token', refresh_token: refresh_token))
-              if resp[:http].code.start_with?('2')
-                # save only if success
-                json_data = resp[:http].body
+              Log.log.info{"refresh token=[#{refresh_token}]".bg_green}
+              begin
+                http = create_token_call(optional_scope_client_id(add_secret: true).merge(grant_type: 'refresh_token', refresh_token: refresh_token))
+                # Save only if success
+                json_data = http.body
                 token_data = JSON.parse(json_data)
                 Factory.instance.persist_mgr.put(@token_cache_id, json_data)
-              else
-                Log.log.debug{"refresh failed: #{resp[:http].body}".bg_red}
+              rescue => e
+                # Refresh token can fail.
+                Log.log.warn{"Refresh failed: #{e}"}
               end
             end
           end
@@ -140,8 +129,9 @@ module Aspera
 
         # no cache, nor refresh: generate a token
         if token_data.nil?
-          resp = create_token
-          json_data = resp[:http].body
+          # Call the method-specific token creation
+          # which returns the result of create_token_call
+          json_data = create_token.body
           token_data = JSON.parse(json_data)
           Factory.instance.persist_mgr.put(@token_cache_id, json_data)
         end

data/lib/aspera/oauth/factory.rb

@@ -156,7 +156,7 @@ module Aspera
       def register_token_creator(creator_class)
         Aspera.assert_type(creator_class, Class)
         id = Factory.class_to_id(creator_class)
-        Log.log.debug{"registering token creator #{id}"}
+        Log.log.debug{"registering creator for #{id}"}
         @token_type_classes[id] = creator_class
       end
 

data/lib/aspera/oauth/url_json.rb

@@ -25,7 +25,8 @@ module Aspera
           query:        @query.merge(scope: scope), # scope is here because it may change over time (node)
           content_type: Rest::MIME_JSON,
           body:         @body,
-          headers:      {'Accept' => Rest::MIME_JSON}
+          headers:      {'Accept' => Rest::MIME_JSON},
+          ret:          :resp
         )
       end
     end

data/lib/aspera/preview/file_types.rb

@@ -3,7 +3,7 @@
 require 'aspera/log'
 require 'aspera/assert'
 require 'singleton'
-require 'mime/types'
+require 'marcel'
 
 module Aspera
   module Preview
@@ -61,7 +61,7 @@ module Aspera
       end
 
       # @param mimetype [String] mime type
-      # @return file type, one of enum CONVERSION_TYPES, or nil if not found
+      # @return [NilClass,Symbol] file type, one of enum CONVERSION_TYPES, or nil if not found
       def mime_to_type(mimetype)
         Aspera.assert_type(mimetype, String)
         return SUPPORTED_MIME_TYPES[mimetype] if SUPPORTED_MIME_TYPES.key?(mimetype)
@@ -72,19 +72,17 @@ module Aspera
         return
       end
 
-      # @param filepath [String] full path to file
-      # @param mimetype [String] provided by node API
+      # @param filepath [String] Full path to file
+      # @param mimetype [String] MIME typre provided by node API
       # @return file type, one of enum CONVERSION_TYPES
       # @raise [RuntimeError] if no conversion type found
       def conversion_type(filepath, mimetype)
         Log.log.debug{"conversion_type(#{filepath},mime=#{mimetype},magic=#{@use_mimemagic})"}
-        mimetype = nil if mimetype.is_a?(String) && (mimetype == 'application/octet-stream' || mimetype.empty?)
-        # Use mimemagic if available
-        mimetype ||= mime_using_mimemagic(filepath)
-        mimetype ||= mime_using_file(filepath)
-        # from extensions, using local mapping
-        mimetype ||= MIME::Types.of(File.basename(filepath)).first
-        raise "no MIME type found for #{File.basename(filepath)}" if mimetype.nil?
+        # Default type or empty means no type
+        mimetype = TYPE_NOT_FOUND if mimetype.nil? || (mimetype.is_a?(String) && mimetype.empty?)
+        mimetype = Marcel::MimeType.for(Pathname.new(filepath), name: File.basename(filepath), declared_type: mimetype)
+        mimetype = 'text/plain' if mimetype.eql?(TYPE_NOT_FOUND) && ascii_text_file?(filepath)
+        raise "no MIME type found for #{File.basename(filepath)}" if mimetype.eql?(TYPE_NOT_FOUND)
         conversion_type = mime_to_type(mimetype)
         raise "no conversion type found for #{File.basename(filepath)}" if conversion_type.nil?
         Log.log.trace1{"conversion_type(#{File.basename(filepath)}): #{conversion_type.class.name} [#{conversion_type}]"}
@@ -93,33 +91,21 @@ module Aspera
 
       private
 
-      # Use mime magic to find mime type based on file content (magic numbers)
-      # @param filepath [String] full path to file
-      # @return [String] mime type, or nil if not found
-      def mime_using_mimemagic(filepath)
-        return unless @use_mimemagic
-        # moved here, as `mimemagic` can cause installation issues
-        require 'mimemagic'
-        require 'mimemagic/version'
-        require 'mimemagic/overlay' if MimeMagic::VERSION.start_with?('0.3.')
-        # check magic number inside file (empty string if not found)
-        detected_mime = MimeMagic.by_magic(File.open(filepath)).to_s
-        # check extension only
-        if mime_to_type(detected_mime).nil?
-          Log.log.debug{"no conversion for #{detected_mime}, trying extension"}
-          detected_mime = MimeMagic.by_extension(File.extname(filepath)).to_s
-        end
-        detected_mime = nil if detected_mime.empty?
-        Log.log.debug{"mimemagic: #{detected_mime.class.name} [#{detected_mime}]"}
-        return detected_mime
-      end
+      TYPE_NOT_FOUND = 'application/octet-stream'
+      ACCEPT_CTRL_CHARS = [9, 10, 13]
 
-      # Use 'file' command to find mime type based on file content (Unix)
-      def mime_using_file(filepath)
-        return Environment.secure_capture(exec: 'file', args: ['--mime-type', '--brief', filepath]).strip
-      rescue => e
-        Log.log.error{"error using 'file' command: #{e.message}"}
-        return
+      # Returns true if the file looks like ASCII text (printable ASCII + \t, \r, \n, space).
+      # It reads only a small prefix (default: 64KB) and fails fast on the first bad byte.
+      def ascii_text_file?(path, sample_size: 64 * 1024)
+        File.open(path, 'rb') do |f|
+          sample = f.read(sample_size) || ''.b
+          sample.each_byte do |b|
+            next if b.between?(32, 126) || ACCEPT_CTRL_CHARS.include?(b)
+            # Any other control character => not ASCII text
+            return false
+          end
+          true
+        end
       end
     end
   end

data/lib/aspera/preview/terminal.rb

@@ -3,11 +3,87 @@
 # cspell:words Magick MAGICKCORE ITERM mintty winsize termcap
 
 require 'rainbow'
+require 'base64'
 require 'io/console'
 require 'aspera/log'
 require 'aspera/environment'
+
 module Aspera
   module Preview
+    module Backend
+      # provides image pixels scaled to terminal
+      class Base
+        def initialize(reserve:, double:, font_ratio:)
+          @reserve = reserve
+          @height_ratio = double ? 2.0 : 1.0
+          @font_ratio = font_ratio
+        end
+        Aspera.require_method!(:terminal_pixels)
+        # compute scaling to fit terminal
+        def terminal_scaling(rows, columns)
+          (term_rows, term_columns) = IO.console.winsize || [24, 80]
+          term_rows = [term_rows - @reserve, 2].max
+          fit_term_ratio = [term_rows.to_f * @font_ratio / rows.to_f, term_columns.to_f / columns.to_f].min
+          [(columns * fit_term_ratio).to_i, (rows * fit_term_ratio * @height_ratio / @font_ratio).to_i]
+        end
+      end
+
+      class RMagick < Base
+        def initialize(blob, **kwargs)
+          super(**kwargs)
+          # do not require statically, as the package is optional
+          require 'rmagick' # https://rmagick.github.io/index.html
+          @image = Magick::ImageList.new.from_blob(blob)
+        end
+
+        def terminal_pixels
+          # quantum depth is 8 or 16, see: `magick xc: -format "%q" info:`
+          shift_for_8_bit = Magick::MAGICKCORE_QUANTUM_DEPTH - 8
+          # get all pixel colors, adjusted for Rainbow
+          pixel_colors = []
+          @image.scale(*terminal_scaling(@image.rows, @image.columns)).each_pixel do |pixel, col, row|
+            pixel_rgb = [pixel.red, pixel.green, pixel.blue]
+            pixel_rgb = pixel_rgb.map{ |color| color >> shift_for_8_bit} unless shift_for_8_bit.eql?(0)
+            # init 2-dim array
+            pixel_colors[row] ||= []
+            pixel_colors[row][col] = pixel_rgb
+          end
+          pixel_colors
+        end
+      end
+
+      class ChunkyPNG < Base
+        def initialize(blob, **kwargs)
+          super(**kwargs)
+          require 'chunky_png'
+          @png = ::ChunkyPNG::Image.from_blob(blob)
+        end
+
+        def terminal_pixels
+          src_w = @png.width
+          src_h = @png.height
+          dst_w, dst_h = terminal_scaling(src_h, src_w)
+          dst_w = [dst_w, 1].max
+          dst_h = [dst_h, 1].max
+          pixel_colors = Array.new(dst_h){Array.new(dst_w)}
+          x_ratio = src_w.to_f / dst_w
+          y_ratio = src_h.to_f / dst_h
+          dst_h.times do |dy|
+            sy = (dy * y_ratio).floor
+            sy = src_h - 1 if sy >= src_h
+            dst_w.times do |dx|
+              sx = (dx * x_ratio).floor
+              sx = src_w - 1 if sx >= src_w
+              rgba = @png.get_pixel(sx, sy)
+              # ChunkyPNG stores as 0xRRGGBBAA; extract 8-bit channels
+              pixel_colors[dy][dx] = %i[r g b].map{ |i| ::ChunkyPNG::Color.send(i, rgba)}
+            end
+          end
+          pixel_colors
+        end
+      end
+    end
+
     # Display a picture in the terminal.
     # Either use coloured characters or iTerm2 protocol.
     class Terminal
@@ -22,41 +98,31 @@ module Aspera
       private_constant :TERM_ENV_VARS, :ITERM_NAMES, :DEFAULT_FONT_RATIO
       class << self
         # @param blob       [String]  The image as a binary string
-        # @param reserve    [Integer] Number of lines to reserve for other text than the image
         # @param text       [Boolean] `true` to display the image as text, `false` to use iTerm2 if supported
+        # @param reserve    [Integer] Number of lines to reserve for other text than the image
         # @param double     [Boolean] `true` to use colors on half lines, `false` to use colors on full lines
         # @param font_ratio [Float]   ratio = font height / font width
         # @return [String] The image as text, or the iTerm2 escape sequence
-        def build(blob, reserve: 3, text: false, double: true, font_ratio: DEFAULT_FONT_RATIO)
+        def build(blob, text: false, reserve: 3, double: true, font_ratio: DEFAULT_FONT_RATIO)
           return '[Image display requires a terminal]' unless Environment.terminal?
           return iterm_display_image(blob) if iterm_supported? && !text
-          begin
-            # do not require statically, as the package is optional
-            require 'rmagick' # https://rmagick.github.io/index.html
-          rescue LoadError => e
-            Log.log.error('Install missing gem: gem install rmagick')
-            # fallback to iterm, if supported
+          pixel_colors =
+            begin
+              Log.log.debug('Trying chunky_png')
+              Backend::ChunkyPNG.new(blob, reserve: reserve, double: double, font_ratio: font_ratio).terminal_pixels
+            rescue => e
+              Log.log.debug(e.message)
+              begin
+                Log.log.debug('Trying rmagick')
+                Backend::RMagick.new(blob, reserve: reserve, double: double, font_ratio: font_ratio).terminal_pixels
+              rescue => e
+                Log.log.debug(e.message)
+                nil
+              end
+            end
+          if pixel_colors.nil?
             return iterm_display_image(blob) if iterm_supported?
-            Log.log.error('Cant display picture.')
-            raise e
-          end
-          image = Magick::ImageList.new.from_blob(blob)
-          (term_rows, term_columns) = IO.console.winsize
-          term_rows -= reserve
-          # compute scaling to fit terminal
-          fit_term_ratio = [term_rows.to_f * font_ratio / image.rows.to_f, term_columns.to_f / image.columns.to_f].min
-          height_ratio = double ? 2.0 : 1.0
-          image = image.scale((image.columns * fit_term_ratio).to_i, (image.rows * fit_term_ratio * height_ratio / font_ratio).to_i)
-          # quantum depth is 8 or 16, see: `magick xc: -format "%q" info:`
-          shift_for_8_bit = Magick::MAGICKCORE_QUANTUM_DEPTH - 8
-          # get all pixel colors, adjusted for Rainbow
-          pixel_colors = []
-          image.each_pixel do |pixel, col, row|
-            pixel_rgb = [pixel.red, pixel.green, pixel.blue]
-            pixel_rgb = pixel_rgb.map{ |color| color >> shift_for_8_bit} unless shift_for_8_bit.eql?(0)
-            # init 2-dim array
-            pixel_colors[row] ||= []
-            pixel_colors[row][col] = pixel_rgb
+            raise 'Cannot decode picture.'
           end
           # now generate text
           text_pixels = []
@@ -88,7 +154,7 @@ module Aspera
           }.map{ |k, v| "#{k}=#{v}"}.join(';')
           # \a is BEL, \e is ESC : https://github.com/ruby/ruby/blob/master/doc/syntax/literals.rdoc#label-Strings
           # escape sequence for iTerm2 image display
-          return "\e]1337;File=#{arguments}:#{Base64.encode64(blob)}\a"
+          return "\e]1337;File=#{arguments}:#{Base64.strict_encode64(blob)}\a"
         end
 
         # @return [Boolean] true if the terminal supports iTerm2 image display

data/lib/aspera/preview/utils.rb

@@ -44,17 +44,18 @@ module Aspera
           end
         end
 
-        # execute external command
-        # one could use "system", but we would need to redirect stdout/err
-        # @return nil
+        # Execute external command
+        # @return [nil]
         def external_command(command_sym, command_args)
           Aspera.assert_values(command_sym, EXTERNAL_TOOLS){'command'}
-          Environment.secure_execute(exec: command_sym.to_s, args: command_args.map(&:to_s), out: File::NULL, err: File::NULL)
+          Environment.secure_execute(command_sym.to_s, *command_args.map(&:to_s), out: File::NULL, err: File::NULL)
         end
 
+        # Execute external command and capture output
+        # @return [String]
         def external_capture(command_sym, command_args)
           Aspera.assert_values(command_sym, EXTERNAL_TOOLS){'command'}
-          return Environment.secure_capture(exec: command_sym.to_s, args: command_args.map(&:to_s))
+          return Environment.secure_execute(command_sym.to_s, *command_args.map(&:to_s), mode: :capture)
         end
 
         def ffmpeg(gl_p: FFMPEG_DEFAULT_PARAMS, in_p: [], in_f:, out_p: [], out_f:)

data/lib/aspera/products/connect.rb

@@ -56,10 +56,10 @@ module Aspera
       # Retrieve structure from cloud (CDN) with all versions available
       def versions
         if @connect_versions.nil?
-          javascript = cdn_api.call(operation: 'GET', subpath: VERSION_INFO_FILE)
+          http = cdn_api.read(VERSION_INFO_FILE, ret: :resp)
           # get result on one line
-          connect_versions_javascript = javascript[:http].body.gsub(/\r?\n\s*/, '')
-          Log.log.debug{"javascript=[\n#{connect_versions_javascript}\n]"}
+          connect_versions_javascript = http.body.gsub(/\r?\n\s*/, '')
+          Log.dump(:javascript, connect_versions_javascript)
           # get javascript object only
           found = connect_versions_javascript.match(/^.*? = (.*);/)
           raise Cli::Error, 'Problem when getting connect versions from internet' if found.nil?