aspera-cli 4.26.1 → 4.27.0

data/lib/aspera/cli/preset_manager.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require 'aspera/cli/extended_value'
+require 'aspera/cli/version'
+require 'aspera/cli/info'
+require 'aspera/log'
+require 'aspera/assert'
+require 'aspera/yaml'
+require 'digest'
+require 'yaml'
+
+module Aspera
+  module Cli
+    # Manages the YAML config file and all preset-related operations.
+    # Extracted from Plugins::Config so it can be referenced independently
+    # via Context#presets without coupling to the plugin machinery.
+    class PresetManager
+      # Reserved keys in the YAML config file
+      module Key
+        CONFIG   = 'config'
+        VERSION  = 'version'
+        DEFAULTS = 'default'
+        GLOBAL   = 'global_common_defaults'
+      end
+
+      GLOBAL_DEFAULT_KEYWORD = 'GLOBAL'
+      CONF_GLOBAL_SYM        = :config
+      # Separator for dot-notation digging into presets
+      PRESET_DIG_SEPARATOR = '.'
+
+      private_constant :PRESET_DIG_SEPARATOR
+
+      # @param config_file [String]       absolute path to the YAML config file
+      # @param use_plugin_defaults [Boolean] if false, skip default preset lookup
+      def initialize(config_file:, use_plugin_defaults: true)
+        @config_file         = config_file
+        @use_plugin_defaults = use_plugin_defaults
+        @config_presets      = {}
+        @checksum_on_disk    = nil
+        read_config_file
+      end
+
+      attr_reader :config_file, :config_presets, :use_plugin_defaults
+      attr_writer :use_plugin_defaults
+
+      # ------------------------------------------------------------------
+      # File I/O
+      # ------------------------------------------------------------------
+
+      # @return [String] SHA1 of current in-memory presets
+      def checksum
+        Digest::SHA1.hexdigest(JSON.generate(@config_presets))
+      end
+
+      # Read and validate the YAML config file.
+      # Sets @config_presets and @checksum_on_disk.
+      def read_config_file
+        Log.log.debug{"config file is: #{@config_file}".red}
+        if File.exist?(@config_file)
+          Log.log.debug{"loading #{@config_file}"}
+          @config_presets   = Yaml.safe_load(File.read(@config_file))
+          @checksum_on_disk = checksum
+        else
+          Log.log.warn{"No config file found. New configuration file: #{@config_file}"}
+          @config_presets = {Key::CONFIG => {Key::VERSION => 'new file'}}
+          # @checksum_on_disk remains nil: will be saved on first write
+        end
+        validate_config_presets!
+      rescue Psych::SyntaxError => e
+        Log.log.error('YAML error in config file')
+        raise e
+      rescue StandardError => e
+        Log.log.debug{"-> #{e.class.name} : #{e}"}
+        if File.exist?(@config_file)
+          new_name = "#{@config_file}.pre#{Cli::VERSION}.manual_conversion_needed"
+          File.rename(@config_file, new_name)
+          Log.log.warn{"Renamed config file to #{new_name}."}
+          Log.log.warn('Manual Conversion is required. Next time, a new empty file will be created.')
+        end
+        raise Cli::Error, e.to_s
+      end
+
+      # Save to disk only if content changed since last load/save.
+      # @return [Boolean] true if actually written
+      def save_if_needed
+        Aspera.assert(!@config_presets.nil?, type: Cli::Error){'no configuration loaded'}
+        current = checksum
+        return false if @checksum_on_disk.eql?(current)
+        FileUtils.mkdir_p(File.dirname(@config_file))
+        Environment.restrict_file_access(File.dirname(@config_file))
+        Log.log.info{"Saving config file: #{@config_file}"}
+        Environment.write_file_restricted(@config_file, force: true){@config_presets.to_yaml}
+        @checksum_on_disk = current
+        true
+      end
+
+      # ------------------------------------------------------------------
+      # Preset read/write helpers
+      # ------------------------------------------------------------------
+
+      # @return [String, nil] name of the default preset for a plugin, or nil
+      def plugin_default_name(plugin_name_sym)
+        Aspera.assert(!@config_presets.nil?, 'config_presets shall be defined')
+        return unless @use_plugin_defaults
+        return unless @config_presets.key?(Key::DEFAULTS)
+        Aspera.assert_type(@config_presets[Key::DEFAULTS], Hash){'default section'}
+        return unless @config_presets[Key::DEFAULTS].key?(plugin_name_sym.to_s)
+        default_name = @config_presets[Key::DEFAULTS][plugin_name_sym.to_s]
+        unless @config_presets.key?(default_name)
+          Log.log.error do
+            "Default config name [#{default_name}] specified for plugin [#{plugin_name_sym}], but it does not exist in config file.\n" \
+              "Please fix: either create preset:\n" \
+              "#{Info::CMD_NAME} config id #{default_name} init @json:'{}'\n" \
+              "or remove default:\n#{Info::CMD_NAME} config id default remove #{plugin_name_sym}"
+          end
+          raise Cli::Error, "No such preset: #{default_name}"
+        end
+        Aspera.assert_type(@config_presets[default_name], Hash, type: Cli::Error){'preset type'}
+        default_name
+      end
+
+      # Resolve and return a deep-cloned, extended copy of a named preset.
+      # Supports dot-notation (e.g. "outer.inner").
+      # @param config_name [String]
+      # @param include_path [Array] guard against include loops
+      def by_name(config_name, include_path = [])
+        Aspera.assert(!include_path.include?(config_name), type: Cli::Error){'loop in include'}
+        include_path = include_path.clone
+        current = @config_presets
+        config_name.split(PRESET_DIG_SEPARATOR).each do |name|
+          Aspera.assert_type(current, Hash, type: Cli::Error){"sub key: #{include_path}"}
+          include_path.push(name)
+          current = current[name]
+          Aspera.assert(!current.nil?, type: Cli::Error){"Unknown config preset: #{include_path}"}
+        end
+        current = self.class.deep_clone(current) unless current.is_a?(String)
+        ExtendedValue.instance.evaluate(current, context: 'preset')
+      end
+
+      # Set a single key in a preset hash (creates the preset if absent).
+      def set_key(preset, param_name, param_value)
+        Aspera.assert_type(param_name, String, Symbol){'parameter'}
+        param_name = param_name.to_s
+        selected = @config_presets[preset]
+        if selected.nil?
+          Log.log.debug{"Unknown preset name: #{preset}, initializing"}
+          selected = @config_presets[preset] = {}
+        end
+        Aspera.assert_type(selected, Hash){"#{preset}.#{param_name}"}
+        if selected.key?(param_name)
+          if selected[param_name].eql?(param_value)
+            Log.log.warn{"keeping same value for #{preset}: #{param_name}: #{param_value}"}
+            return
+          end
+          Log.log.warn{"overwriting value for #{param_name}: #{selected[param_name]}"}
+        end
+        selected[param_name] = param_value
+        Log.log.info("Updated: #{preset}: #{param_name} <- #{param_value}")
+        nil
+      end
+
+      # @return [String] name of the global default preset, creating it if needed
+      def global_default_preset
+        result = plugin_default_name(CONF_GLOBAL_SYM)
+        if result.nil?
+          result = Key::GLOBAL
+          set_key(Key::DEFAULTS, CONF_GLOBAL_SYM, result)
+        end
+        result
+      end
+
+      # Set param in the global defaults preset
+      def set_global_default(key, value)
+        set_key(global_default_preset, key, value)
+      end
+
+      # Create / overwrite a preset and optionally set it as plugin default.
+      def defaults_set(plugin_name, preset_name, preset_values, option_default, option_override)
+        @config_presets[Key::DEFAULTS] ||= {}
+        raise Cli::Error, "A default configuration already exists for plugin '#{plugin_name}' (use --override=yes or --default=no)" \
+          if !option_override && option_default && @config_presets[Key::DEFAULTS].key?(plugin_name)
+        raise Cli::Error, "Preset already exists: #{preset_name}  (use --override=yes or provide alternate name on command line)" \
+          if !option_override && @config_presets.key?(preset_name)
+        if option_default
+          Log.log.info("Setting config preset as default for #{plugin_name}")
+          @config_presets[Key::DEFAULTS][plugin_name.to_s] = preset_name
+        end
+        @config_presets[preset_name] = preset_values
+      end
+
+      # Find the first preset whose url+username match
+      # @return [Hash, nil]
+      def lookup_preset(url:, username:)
+        url = canonical_url(url)
+        Log.log.debug{"Lookup preset for #{username}@#{url}"}
+        @config_presets.each_value do |v|
+          next unless v.is_a?(Hash)
+          conf_url = v['url'].is_a?(String) ? canonical_url(v['url']) : nil
+          return self.class.deep_clone(v) if conf_url.eql?(url) && v['username'].eql?(username)
+        end
+        nil
+      end
+
+      # ------------------------------------------------------------------
+      # Class helpers
+      # ------------------------------------------------------------------
+
+      class << self
+        def deep_clone(val)
+          Marshal.load(Marshal.dump(val))
+        end
+      end
+
+      private
+
+      # Normalize a URL for comparison
+      def canonical_url(url)
+        url.chomp('/').sub(%r{^(https://[^/]+):443$}, '\1')
+      end
+
+      # Structural validation + compatibility fixes on @config_presets
+      def validate_config_presets!
+        Log.dump(:available_presets, @config_presets, level: :trace1)
+        Aspera.assert_type(@config_presets, Hash){'config file YAML'}
+        Aspera.assert(@config_presets.key?(Key::CONFIG)){"Cannot find key: #{Key::CONFIG}"}
+        version = @config_presets[Key::CONFIG][Key::VERSION]
+        Aspera.assert(!version.nil?, type: Cli::Error){'No version found in config section.'}
+        Log.log.debug{"conf version: #{version}"}
+        # Fix bug in 4.4 (creating key "true" in "default" preset)
+        @config_presets[Key::DEFAULTS].delete(true) if @config_presets[Key::DEFAULTS].is_a?(Hash)
+        # Stamp with current version
+        @config_presets[Key::CONFIG][Key::VERSION] = Cli::VERSION
+      end
+    end
+  end
+end

data/lib/aspera/cli/result.rb

@@ -0,0 +1,360 @@
+# frozen_string_literal: true
+
+require 'aspera/assert'
+require 'aspera/nagios'
+require 'aspera/log'
+require 'aspera/environment'
+require 'aspera/uri_reader'
+require 'aspera/preview/terminal'
+require 'aspera/dot_container'
+require 'base64'
+require 'uri'
+require 'pp'
+require 'json'
+require 'yaml'
+
+module Aspera
+  module Cli
+    # Base class for all result types
+    # Each result type is now a separate class instead of using a type field
+    class Result
+      attr_reader :data, :fields
+
+      # @param data [Object,nil] The result data
+      # @param fields [Object] Specification of fields to include
+      def initialize(data: nil, fields: nil)
+        @data = data
+        @fields = fields
+      end
+
+      # Format this result using the provided formatter
+      # This method implements the Visitor pattern, allowing each Result subclass
+      # to define how it should be formatted without the Formatter needing to know
+      # about all Result types.
+      # Base implementation handles common formats: text, nagios, ruby, json, jsonpp, yaml
+      # Subclasses should call super first, then handle their specific formats
+      # @param formatter [Formatter] The formatter to use
+      # @return [nil]
+      def format(formatter)
+        # Apply field filtering once for formats that need it
+        filtered_data = formatter.filter_list_on_fields(@data)
+        case formatter.format_type
+        when :text
+          formatter.display_message(:data, @data.to_s)
+        when :nagios
+          Nagios.process(@data)
+        when :ruby
+          formatter.display_message(:data, PP.pp(filtered_data, +''))
+        when :json
+          formatter.display_message(:data, JSON.generate(filtered_data))
+        when :jsonpp
+          formatter.display_message(:data, JSON.pretty_generate(filtered_data))
+        when :yaml
+          formatter.display_message(:data, YAML.dump(filtered_data))
+        when :image
+          if @data.nil?
+            formatter.display_message(:data, formatter.special_format('null (no image)'))
+            return
+          end
+          Aspera.assert_type(@data, String){'image: URL or blob'}
+          # Check if URL
+          data =
+            begin
+              # just validate
+              URI.parse(@data)
+              if Environment.instance.url_method.eql?(:text)
+                UriReader.read(@data)
+              else
+                Environment.instance.open_uri(@data)
+                formatter.display_message(:info, "Opened URL in browser: #{@data}")
+                :done
+              end
+            rescue URI::InvalidURIError
+              @data
+            end
+          unless data.eql?(:done)
+            # try base64
+            data = begin
+              Base64.strict_decode64(data)
+            rescue ArgumentError
+              data
+            end
+            # here, data is the image blob
+            formatter.display_message(:data, Preview::Terminal.build(data, **formatter.image_options))
+          end
+        else
+          Aspera.error_unexpected_value(formatter.format_type){'format'}
+        end
+      end
+    end
+
+    # Special result types - each has its own class
+    class Result
+      # Base class for special results
+      # The type is automatically derived from the class name
+      class Special < Result
+        def initialize
+          # Convert class name to symbol: Empty -> :empty, Nothing -> :nothing
+          type = self.class.name.split('::').last.gsub(/([a-z])([A-Z])/, '\1_\2').downcase.to_sym
+          super(data: type)
+        end
+
+        def format(formatter)
+          case formatter.format_type
+          when :text, :nagios, :ruby, :json, :jsonpp, :yaml
+            formatter.display_message(:data, @data.to_s)
+          when :table, :csv
+            if @data.eql?(:nothing)
+              Log.log.debug('no result expected')
+              return
+            end
+            formatter.display_message(:info, formatter.special_format(@data.to_s))
+          else
+            super
+          end
+        end
+      end
+
+      # Empty list result
+      class Empty < Special
+      end
+
+      # Nothing expected result
+      class Nothing < Special
+      end
+
+      # Null result
+      class Null < Special
+      end
+
+      # Status result (success, complete, etc.)
+      class Status < Result
+        def initialize(data)
+          Aspera.assert_type(data, String){'status result data'}
+          super(data: data)
+        end
+
+        def format(formatter)
+          data = formatter.hide_secrets? ? formatter.hide_secrets_in_string(@data) : @data
+          case formatter.format_type
+          when :text, :nagios, :ruby, :json, :jsonpp, :yaml
+            formatter.display_message(:data, data)
+          when :table, :csv
+            formatter.display_message(:info, data)
+          else
+            super
+          end
+        end
+      end
+
+      # Success status result
+      class Success < Status
+        def initialize
+          super('complete')
+        end
+      end
+
+      # Text result
+      class Text < Result
+        def initialize(data)
+          Aspera.assert_type(data, String, Integer, Symbol, type: ArgumentError){'text result data'}
+          super(data: data)
+        end
+
+        def format(formatter)
+          data = @data.is_a?(String) && formatter.hide_secrets? ? formatter.hide_secrets_in_string(@data) : @data
+          case formatter.format_type
+          when :text, :nagios
+            formatter.display_message(:data, data.to_s)
+          when :ruby
+            formatter.display_message(:data, PP.pp(data, +''))
+          when :json
+            formatter.display_message(:data, JSON.generate(data))
+          when :jsonpp
+            formatter.display_message(:data, JSON.pretty_generate(data))
+          when :yaml
+            formatter.display_message(:data, YAML.dump(data))
+          when :table, :csv
+            formatter.display_message(:data, data)
+          else
+            super
+          end
+        end
+      end
+
+      # Image result (URL or blob)
+      class Image < Result
+        def initialize(data)
+          Aspera.assert_type(data, String, NilClass){'image result data'}
+          super(data: data)
+        end
+
+        def format(formatter)
+          # Force image format for Image results
+          formatter.format_type = :image
+          super
+        end
+      end
+
+      # Single object result (Hash)
+      class SingleObject < Result
+        def initialize(data, fields: nil)
+          Aspera.assert_type(data, Hash){'single object result data'}
+          super(data: data, fields: fields)
+        end
+
+        def format(formatter)
+          case formatter.format_type
+          when :image
+            # Extract single field for image display
+            data_array = [@data]
+            fields = formatter.compute_fields(data_array, @fields)
+            Aspera.assert(fields.length == 1, 'select a single field to display', type: Cli::BadArgument)
+            Aspera.assert(@data.key?(fields.first), 'no such field', type: Cli::BadArgument)
+            # Create an Image result and format it
+            Image.new(@data[fields.first]).format(formatter)
+          when :table, :csv
+            Aspera.assert_type(@data, Hash){'result'}
+            if @data.empty?
+              formatter.display_message(:data, formatter.special_format('empty dict'))
+            else
+              data = formatter.flat_hash? ? DotContainer.new(@data).to_dotted : @data
+              formatter.display_table([data], formatter.compute_fields([data], @fields), single: true)
+            end
+          else
+            super
+          end
+        end
+      end
+
+      # Object list result (Array of Hash)
+      # @note The +total+ parameter is used to display pagination information (e.g., "Items: 10/100")
+      class ObjectList < Result
+        attr_reader :total
+
+        # @param data [Array<Hash>] Array of hash objects to display
+        # @param fields [Array<String>, Proc, nil] Fields to display in table/csv format
+        # @param total [Integer, nil] Total number of items available (for pagination display)
+        def initialize(data, fields: nil, total: nil)
+          Aspera.assert_array_all(data, Hash, type: ArgumentError){'object list result data'}
+          Aspera.assert_type(total, Integer, NilClass){'total'}
+          super(data: data, fields: fields)
+          @total = total
+        end
+
+        def format(formatter)
+          formatter.display_item_count(@data.length, @total)
+          case formatter.format_type
+          when :image
+            # Extract single field for image display
+            Aspera.assert(@data.length == 1, 'image display requires a single result', type: Cli::BadArgument)
+            SingleObject.new(@data.first).format(formatter)
+          when :table, :csv
+            Aspera.assert_array_all(@data, Hash){'result'}
+            data = formatter.flat_hash? ? @data.map{ |obj| DotContainer.new(obj).to_dotted} : @data
+            formatter.display_table(data, formatter.compute_fields(data, @fields), single: false)
+          else
+            super
+          end
+        end
+      end
+
+      # Value list result (Array of values with a name)
+      class ValueList < Result
+        attr_reader :name
+
+        def initialize(data, name: 'id')
+          Aspera.assert_type(data, Array){'value list result data'}
+          Aspera.assert_type(name, String){'value list name'}
+          super(data: data)
+          @name = name
+        end
+
+        def format(formatter)
+          case formatter.format_type
+          when :table, :csv
+            formatter.display_table(@data.map{ |i| {@name => i}}, [@name])
+          when :text
+            formatter.display_message(:data, @data.join("\n"))
+          when :ruby
+            formatter.display_message(:data, PP.pp(@data, +''))
+          when :json
+            formatter.display_message(:data, JSON.generate(@data))
+          when :jsonpp
+            formatter.display_message(:data, JSON.pretty_generate(@data))
+          when :yaml
+            formatter.display_message(:data, YAML.dump(@data))
+          else
+            super
+          end
+        end
+      end
+
+      class << self
+        # Execute a bulk operation over a list of already-resolved items and return a CLI result.
+        # This is a pure helper: it reads nothing from the CLI.
+        # @param items   [Array]   List of items to process (one element when non-bulk)
+        # @param is_bulk [Boolean] Whether the caller is in bulk mode
+        # @param command [Symbol]  Operation name (:create, :delete, …) used to build the past-tense status string
+        # @param id_result [String] Key in the result Hash used as item identifier
+        # @param fields   [Object] Fields hint passed to the Result constructor (non-bulk only, when not :default)
+        # @param bfail    [Boolean] When true, re-raise errors; when false, capture them as a status string
+        # @yieldparam item [Object] Each item in +items+
+        # @yieldreturn [Hash, Array, nil] REST response; a Hash replaces the default id-keyed result
+        # @return [Result::ObjectList, Result::SingleObject]
+        def bulk(items, is_bulk:, command:, id_result: 'id', fields: :default, bfail: true)
+          Aspera.assert(block_given?, 'missing block')
+          Log.log.warn('Empty list given for bulk operation') if items.empty?
+          Log.dump(:bulk_operation, items)
+          result_list = []
+          items.each do |item|
+            result = {id_result => item}
+            begin
+              res = yield(item)
+              result = res if res.is_a?(Hash)
+              # TODO: remove when faspio gw api fixes this
+              result = res.first if res.is_a?(Array) && res.first.is_a?(Hash)
+              result['status'] = "#{command}#{'e' unless command.to_s.end_with?('e')}d".gsub(/yed$/, 'ied')
+            rescue StandardError => e
+              raise e if bfail
+              result['status'] = e.to_s
+            end
+            result_list.push(result)
+          end
+          display_fields = [id_result, 'status']
+          if is_bulk
+            return ObjectList.new(result_list, fields: display_fields)
+          else
+            display_fields = fields unless fields.eql?(:default)
+            return SingleObject.new(result_list.first, fields: display_fields)
+          end
+        end
+
+        # Class method to automatically determine result type from data
+        # @param data [Object] the data to analyze and format
+        # @return [Result]
+        def auto(data)
+          case data
+          when NilClass
+            Null.new
+          when Hash
+            SingleObject.new(data)
+          when Array
+            all_types = data.map(&:class).uniq
+            return ObjectList.new(data) if all_types.eql?([Hash])
+
+            scalar_types = [String, Integer, Symbol]
+            unsupported_types = all_types - scalar_types
+            return ValueList.new(data, name: 'list') if unsupported_types.empty?
+
+            Aspera.error_unexpected_value(unsupported_types){'list item types'}
+          when String, Integer, Symbol
+            Text.new(data)
+          else
+            Aspera.error_unexpected_value(data.class.name){'result type'}
+          end
+        end
+      end
+    end
+  end
+end