aspera-cli 4.25.1 → 4.25.2

data/lib/aspera/faspex_postproc.rb

@@ -27,8 +27,9 @@ module Aspera
     # :reek:UncommunicativeMethodName
     def do_POST(request, response)
       Log.log.debug{"request=#{request.path}"}
+      Log.log.debug{"query=#{request.query}"}
       begin
-        # only accept requests on the root
+        # Only accept requests on the root
         if !request.path.start_with?(@parameters[:root])
           response.status = 400
           response['Content-Type'] = Rest::MIME_JSON
@@ -48,16 +49,21 @@ module Aspera
         Log.log.debug{"script=#{script_path}"}
         webhook_parameters = JSON.parse(request.body)
         Log.dump(:webhook_parameters, webhook_parameters)
-        # env expects only strings
-        environment = webhook_parameters.each_with_object({}){ |(k, v), h| h[k] = v.to_s}
-        post_proc_pid = Environment.secure_execute(script_path, mode: :background, env: environment)
-        Timeout.timeout(@parameters[:timeout_seconds]) do
-          # "wait" for process to avoid zombie
-          Process.wait(post_proc_pid)
-          post_proc_pid = nil
+        if request.query.key?('lambda')
+          # Code can throw exception, source code must return a lambda
+          Environment.secure_eval(File.read(script_path), __FILE__, __LINE__).call(webhook_parameters)
+        else
+          # env expects only strings
+          environment = webhook_parameters.each_with_object({}){ |(k, v), h| h[k] = v.to_s}
+          post_proc_pid = Environment.secure_execute(script_path, mode: :background, env: environment)
+          Timeout.timeout(@parameters[:timeout_seconds]) do
+            # "wait" for process to avoid zombie
+            Process.wait(post_proc_pid)
+            post_proc_pid = nil
+          end
+          process_status = $CHILD_STATUS
+          raise "script #{script_path} failed with code #{process_status.exitstatus}" if !process_status.success? && @parameters[:fail_on_error]
         end
-        process_status = $CHILD_STATUS
-        raise "script #{script_path} failed with code #{process_status.exitstatus}" if !process_status.success? && @parameters[:fail_on_error]
         response.status = 200
         response.content_type = Rest::MIME_JSON
         response.body = JSON.generate({status: 'success', script: script_path, exit_code: process_status.exitstatus})

data/lib/aspera/hash_ext.rb

@@ -26,6 +26,10 @@ unless Hash.method_defined?(:symbolize_keys)
     def symbolize_keys
       return transform_keys(&:to_sym)
     end
+
+    def symbolize_keys!
+      return transform_keys!(&:to_sym)
+    end
   end
 end
 
@@ -35,5 +39,9 @@ unless Hash.method_defined?(:stringify_keys)
     def stringify_keys
       return transform_keys(&:to_s)
     end
+
+    def stringify_keys!
+      return transform_keys!(&:to_s)
+    end
   end
 end

data/lib/aspera/log.rb

@@ -174,11 +174,10 @@ module Aspera
       Logger::SEVERITY_LABEL[@logger.level].downcase
     end
 
-    # Change underlying logger, but keep log level
+    # Change underlying logger, but keep log level (default: INFO)
     def logger_type=(new_log_type)
-      current_severity_integer = @logger.level unless @logger.nil?
-      current_severity_integer = ENV.fetch('AS_LOG_LEVEL', nil) if current_severity_integer.nil? && ENV.key?('AS_LOG_LEVEL')
-      current_severity_integer = Logger::Severity::WARN if current_severity_integer.nil?
+      # [Integer]
+      current_severity_integer = @logger&.level || ENV['AS_LOG_LEVEL']&.to_i || Logger::Severity::INFO
       case new_log_type
       when :stderr
         @logger = Logger.new($stderr, progname: @program_name, formatter: DEFAULT_FORMATTER)

data/lib/aspera/markdown.rb

@@ -26,6 +26,23 @@ module Aspera
       def list(items)
         items.map{ |i| "- #{i}"}.join("\n")
       end
+
+      def heading(title, level: 1)
+        "#{'#' * level} #{title}\n\n"
+      end
+
+      # type: NOTE CAUTION WARNING IMPORTANT TIP INFO
+      def admonition(lines, type: 'INFO')
+        "> [!{type}]\n#{lines.map{ |l| "> #{l}"}.join("\n")}\n\n"
+      end
+
+      def code(lines, type: 'shell')
+        "```#{type}\n#{lines.join("\n")}\n```\n\n"
+      end
+
+      def paragraph(text)
+        "#{text}\n\n"
+      end
     end
   end
 end

data/lib/aspera/oauth/base.rb

@@ -99,7 +99,7 @@ module Aspera
             # 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 token=[#{refresh_token}]".bg_green}
+              Log.log.debug{"refresh token=[#{refresh_token}]"}
               begin
                 http = create_token_call(base_params(add_secret: true).merge(grant_type: 'refresh_token', refresh_token: refresh_token))
                 # Save only if success

data/lib/aspera/oauth/web.rb

@@ -35,7 +35,7 @@ module Aspera
           base_params.merge(response_type: 'code', redirect_uri: @redirect_uri, state: random_state)
         )
         # here, we need a human to authorize on a web page
-        Log.log.info{"login_page_url=#{login_page_url}".bg_red.gray}
+        Log.log.debug{"login_page_url=#{login_page_url}"}
         # start a web server to receive request code
         web_server = WebAuth.new(@redirect_uri, self.class.additional_info)
         # start browser on login page

data/lib/aspera/preview/generator.rb

@@ -23,18 +23,18 @@ module Aspera
       # one of CONVERSION_TYPES
       attr_reader :conversion_type
 
-      # node API mime types are from: http://svn.apache.org/repos/asf/httpd/httpd/trunk/docs/conf/mime.types
-      # the resulting preview file type is taken from destination file extension.
-      # conversion methods are provided by private methods: convert_<conversion_type>_to_<preview_format>
+      # Node API MIME types are from: http://svn.apache.org/repos/asf/httpd/httpd/trunk/docs/conf/mime.types
+      # The resulting preview file type is taken from destination file extension.
+      # Conversion methods are provided by private methods: convert_<conversion_type>_to_<preview_format>
       #   -> conversion_type is one of FileTypes::CONVERSION_TYPES
       #   -> preview_format is one of Generator::PREVIEW_FORMATS
-      # the conversion video->mp4 is implemented in methods: convert_video_to_mp4_using_<video_conversion>
+      # The conversion video->mp4 is implemented in methods: convert_video_to_mp4_using_<video_conversion>
       #  -> conversion method is one of Generator::VIDEO_CONVERSION_METHODS
       # @param src           [String]  source file path
       # @param dst           [String]  destination file path
       # @param options       [Options] All conversion options
       # @param main_temp_dir [String]  Main temp folder, sub folder will be created for generation
-      # @param api_mime_type [String,nil] Optional mime type as provided by node api (or nil)
+      # @param api_mime_type [String,nil] Optional MIME type as provided by node api (or nil)
       def initialize(src, dst, options, main_temp_dir, api_mime_type)
         @source_file_path = src
         @destination_file_path = dst
@@ -57,9 +57,9 @@ module Aspera
         Aspera.assert(respond_to?(@processing_method, true)){"no processing known for #{conversion_type} -> #{@preview_format_sym}"}
       end
 
-      # create preview as specified in constructor
+      # Create preview as specified in constructor.
       def generate
-        Log.log.info{"#{@source_file_path}->#{@destination_file_path} (#{@processing_method})"}
+        Log.log.debug{"#{@source_file_path}->#{@destination_file_path} (#{@processing_method})"}
         begin
           send(@processing_method)
           # check that generated size does not exceed maximum
@@ -76,17 +76,17 @@ module Aspera
 
       private
 
-      # creates a unique temp folder for file
+      # Creates a unique temp folder for file.
       def this_tmpdir
         FileUtils.mkdir_p(@temp_folder)
         return @temp_folder
       end
 
-      # @return offset in seconds suitable for ffmpeg -ss option
       # @param duration of video
       # @param start_offset of parts
       # @param total_count of parts
       # @param index of part (start at 1)
+      # @return [Integer] offset in seconds suitable for ffmpeg -ss option
       def get_offset(duration, start_offset, total_count, index)
         Aspera.assert_type(duration, Float){'duration'}
         return start_offset + ((index - 1) * (duration - start_offset) / total_count)

data/lib/aspera/rest_call_error.rb

@@ -3,15 +3,23 @@
 module Aspera
   # raised on error after REST call
   class RestCallError < StandardError
-    attr_reader :request, :response
+    def request
+      @context[:request]
+    end
+
+    def response
+      @context[:response]
+    end
+
+    def data
+      @context[:data]
+    end
 
-    # @param req HTTP Request object
-    # @param resp HTTP Response object
-    # @param msg Error message
-    def initialize(msg, req = nil, resp = nil)
-      @request = req
-      @response = resp
-      super(msg)
+    # @param context [Hash,String] with keys :messages, :request, :response, :data
+    def initialize(context)
+      context = {messages: [context]} if context.is_a?(String)
+      @context = context
+      super(@context[:messages].join("\n"))
     end
   end
 end

data/lib/aspera/rest_error_analyzer.rb

@@ -46,7 +46,7 @@ module Aspera
           Log.log.error{"ERROR in handler:\n#{e.message}\n#{e.backtrace}"}
         end
       end
-      raise RestCallError.new(call_context[:messages].join("\n"), call_context[:request], call_context[:response]) unless call_context[:messages].empty?
+      raise RestCallError.new(call_context) unless call_context[:messages].empty?
     end
 
     # add a new error handler (done at application initialization)

data/lib/aspera/transfer/resumer.rb

@@ -41,14 +41,14 @@ module Aspera
         Log.log.debug{"retries=#{remaining_resumes}"}
         # try to send the file until ascp is successful
         loop do
-          Log.log.debug('Transfer session starting')
+          Log.log.debug('Starting task execution')
           begin
             # Call provided block: execute transfer
             yield
             # Exit retry loop if success
             break
           rescue Error => e
-            Log.log.warn{"A transfer error occurred during transfer: #{e.message}"}
+            Log.log.warn{"An error occurred during task: #{e.message}"}
             Log.log.debug{"Retryable ? #{e.retryable?}"}
             # do not retry non-retryable
             raise unless e.retryable?

data/lib/aspera/yaml.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Aspera
+  module Yaml
+    # @param node [Psych::Nodes::Node] YAML node
+    # @param parent_path [Array<String>] Path of parent keys
+    # @param duplicate_keys [Array<Hash>] Accumulated duplicate keys
+    # @return [Array<String>] List of duplicate keys with their paths and occurrences
+    def find_duplicate_keys(node, parent_path = nil, duplicate_keys = nil)
+      duplicate_keys ||= []
+      parent_path ||= []
+      return duplicate_keys unless node.respond_to?(:children)
+      if node.is_a?(Psych::Nodes::Mapping)
+        counts = Hash.new(0)
+        key_nodes = Hash.new{ |h, k| h[k] = []}
+        node.children.each_slice(2) do |key_node, value_node|
+          if key_node&.value
+            counts[key_node.value] += 1
+            key_nodes[key_node.value] << key_node
+            find_duplicate_keys(value_node, parent_path + [key_node.value], duplicate_keys)
+          end
+        end
+        counts.each do |key_str, count|
+          next if count <= 1
+          path = (parent_path + [key_str]).join('.')
+          occurrences = key_nodes[key_str].map{ |kn| kn.start_line ? kn.start_line + 1 : 'unknown'}.map(&:to_s).join(', ')
+          duplicate_keys << "#{path}: #{occurrences}"
+        end
+      else
+        node.children.to_a.each{ |child| find_duplicate_keys(child, parent_path, duplicate_keys)}
+      end
+      duplicate_keys
+    end
+
+    # Safely load YAML content, raising an error if duplicate keys are found
+    # @param yaml [String] YAML content
+    # @return [Object] Parsed YAML content
+    # @raise [RuntimeError] If duplicate keys are found
+    def safe_load(yaml)
+      duplicate_keys = find_duplicate_keys(Psych.parse_stream(yaml))
+      raise "Duplicate keys: #{duplicate_keys.join('; ')}" unless duplicate_keys.empty?
+      YAML.safe_load(yaml)
+    end
+
+    module_function :find_duplicate_keys, :safe_load
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aspera-cli
 version: !ruby/object:Gem::Version
-  version: 4.25.1
+  version: 4.25.2
 platform: ruby
 authors:
 - Laurent Martin
@@ -108,6 +108,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: marcel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: mime-types
   requirement: !ruby/object:Gem::Requirement
@@ -430,9 +444,9 @@ files:
 - lib/aspera/uri_reader.rb
 - lib/aspera/web_auth.rb
 - lib/aspera/web_server_simple.rb
+- lib/aspera/yaml.rb
 - lib/transferd_pb.rb
 - lib/transferd_services_pb.rb
-- release_notes.md
 homepage: https://github.com/IBM/aspera-cli
 licenses:
 - Apache-2.0

data/release_notes.md

@@ -1,8 +0,0 @@
-## 4.25.1
-
-Released: 2026-01-21
-
-### Issues Fixed
-
-* `build`: Fixed deploy workflow to use global rake instead of bundle exec.
-* `build`: Made rspec require conditional in test.rake for deploy environment.