aspera-cli 4.10.0 → 4.11.0

data/lib/aspera/node.rb

@@ -9,22 +9,23 @@ require 'zlib'
 require 'base64'
 
 module Aspera
-  # Provides additional functions using node API.
-  class Node < Rest
+  # Provides additional functions using node API with gen4 extensions (access keys)
+  class Node < Aspera::Rest
     # permissions
     ACCESS_LEVELS = %w[delete list mkdir preview read rename write].freeze
     # prefix for ruby code for filter
     MATCH_EXEC_PREFIX = 'exec:'
+    X_ASPERA_ACCESSKEY = 'X-Aspera-AccessKey'
+    PATH_SEPARATOR = '/'
 
     # register node special token decoder
     Oauth.register_decoder(lambda{|token|JSON.parse(Zlib::Inflate.inflate(Base64.decode64(token)).partition('==SIGNATURE==').first)})
 
+    # class instance variable, access with accessors on class
+    @use_standard_ports = true
+
     class << self
-      def set_ak_basic_token(ts,ak,secret)
-        Log.log.warn("Expected transfer user: #{Fasp::TransferSpec::ACCESS_KEY_TRANSFER_USER}, "\
-          "but have #{ts['remote_user']}") unless ts['remote_user'].eql?(Fasp::TransferSpec::ACCESS_KEY_TRANSFER_USER)
-        ts['token'] = Rest.basic_creds(ak,secret)
-      end
+      attr_accessor :use_standard_ports
 
       # for access keys: provide expression to match entry in folder
       # if no prefix: regex
@@ -39,49 +40,222 @@ module Aspera
       end
     end
 
-    #    def initialize(rest_params)
-    #      super(rest_params)
-    #    end
+    REQUIRED_APP_INFO_FIELDS = %i[node_info app api plugin].freeze
+    REQUIRED_APP_API_METHODS = %i[node_id_to_api add_ts_tags].freeze
+    private_constant :REQUIRED_APP_INFO_FIELDS, :REQUIRED_APP_API_METHODS
+
+    attr_reader :app_info
+
+    # @param params [Hash] Rest parameters
+    # @param app_info [Hash,NilClass] special processing for AoC
+    def initialize(params:, app_info: nil, add_tspec: nil)
+      super(params)
+      @app_info = app_info
+      # this is added to transfer spec, for instance to add tags (COS)
+      @add_tspec = add_tspec
+      if !@app_info.nil?
+        REQUIRED_APP_INFO_FIELDS.each do |field|
+          raise "INTERNAL ERROR: app_info lacks field #{field}" unless @app_info.key?(field)
+        end
+        REQUIRED_APP_API_METHODS.each do |method|
+          raise "INTERNAL ERROR: #{@app_info[:api].class} lacks method #{method}" unless @app_info[:api].respond_to?(method)
+        end
+      end
+    end
+
+    # update transfer spec with special additional tags
+    def add_tspec_info(tspec)
+      tspec.deep_merge!(@add_tspec) unless @add_tspec.nil?
+      return tspec
+    end
+
+    # @returns [Aspera::Node] a Node or nil
+    def node_id_to_node(node_id)
+      return self if !@app_info.nil? && @app_info[:node_info]['id'].eql?(node_id)
+      return @app_info[:api].node_id_to_api(node_id) unless @app_info.nil?
+      Log.log.warn{"cannot resolve link with node id #{node_id}"}
+      return nil
+    end
 
-    # recursively crawl in a folder.
+    # recursively browse in a folder (with non-recursive method)
     # subfolders a processed if the processing method returns true
-    # @param processor must provide a method to process each entry
-    # @param opt options
-    # - top_file_id file id to start at (default = access key root file id)
-    # - top_file_path path of top folder (default = /)
-    # - method processing method (default= process_entry)
-    def crawl(processor,opt={})
-      Log.log.debug("crawl1 #{opt}")
-      # not possible with bearer token
-      opt[:top_file_id] ||= read('access_keys/self')[:data]['root_file_id']
-      opt[:top_file_path] ||= '/'
-      opt[:method] ||= :process_entry
-      raise "processor must have #{opt[:method]}" unless processor.respond_to?(opt[:method])
-      Log.log.debug("crawl #{opt}")
-      #top_info=read("files/#{opt[:top_file_id]}")[:data]
-      folders_to_explore = [{id: opt[:top_file_id], relpath: opt[:top_file_path]}]
-      Log.dump(:folders_to_explore,folders_to_explore)
-      while !folders_to_explore.empty?
+    # @param state [Object] state object sent to processing method
+    # @param method [Symbol] processing method name
+    # @param top_file_id [String] file id to start at (default = access key root file id)
+    # @param top_file_path [String] path of top folder (default = /)
+    def process_folder_tree(state:, method:, top_file_id:, top_file_path: '/')
+      raise 'INTERNAL ERROR: top_file_path not set' if top_file_path.nil?
+      raise "INTERNAL ERROR: Missing method #{method}" unless respond_to?(method)
+      folders_to_explore = [{id: top_file_id, relpath: top_file_path}]
+      Log.dump(:folders_to_explore, folders_to_explore)
+      until folders_to_explore.empty?
         current_item = folders_to_explore.shift
-        Log.log.debug("searching #{current_item[:relpath]}".bg_green)
+        Log.log.debug{"searching #{current_item[:relpath]}".bg_green}
         # get folder content
         folder_contents =
           begin
             read("files/#{current_item[:id]}/files")[:data]
           rescue StandardError => e
-            Log.log.warn("#{current_item[:relpath]}: #{e.class} #{e.message}")
+            Log.log.warn{"#{current_item[:relpath]}: #{e.class} #{e.message}"}
             []
           end
-        Log.dump(:folder_contents,folder_contents)
+        Log.dump(:folder_contents, folder_contents)
         folder_contents.each do |entry|
-          relative_path = File.join(current_item[:relpath],entry['name'])
-          Log.log.debug("looking #{relative_path}".bg_green)
+          relative_path = File.join(current_item[:relpath], entry['name'])
+          Log.log.debug{"looking #{relative_path}".bg_green}
+          # continue only if method returns true
+          next unless send(method, entry, relative_path, state)
           # entry type is file, folder or link
-          if processor.send(opt[:method],entry,relative_path) && entry['type'].eql?('folder')
-            folders_to_explore.push({id: entry['id'],relpath: relative_path})
+          case entry['type']
+          when 'folder'
+            folders_to_explore.push({id: entry['id'], relpath: relative_path})
+          when 'link'
+            node_id_to_node(entry['target_node_id'])&.process_folder_tree(
+              state:         state,
+              method:        method,
+              top_file_id:   entry['target_id'],
+              top_file_path: relative_path)
           end
         end
       end
+    end # process_folder_tree
+
+    # processing method to resolve a file path to id
+    # @returns true if processing need to continue
+    def process_resolve_node_path(entry, _path, state)
+      # stop digging here if not in right path
+      return false unless entry['name'].eql?(state[:path].first)
+      # ok it matches, so we remove the match
+      state[:path].shift
+      case entry['type']
+      when 'file'
+        # file must be terminal
+        raise "#{entry['name']} is a file, expecting folder to find: #{state[:path]}" unless state[:path].empty?
+        # it's terminal, we found it
+        state[:result] = {api: self, file_id: entry['id']}
+        return false
+      when 'folder'
+        if state[:path].empty?
+          # we found it
+          state[:result] = {api: self, file_id: entry['id']}
+          return false
+        end
+      when 'link'
+        if state[:path].empty?
+          # we found it
+          other_node = node_id_to_node(entry['target_node_id'])
+          raise 'cannot resolve link' if other_node.nil?
+          state[:result] = {api: other_node, file_id: entry['target_id']}
+          return false
+        end
+      else
+        Log.log.warn{"Unknown element type: #{entry['type']}"}
+      end
+      # continue to dig folder
+      return true
+    end
+
+    # Navigate the path from given file id
+    # @param id initial file id
+    # @param path file path
+    # @return {.api,.file_id}
+    def resolve_api_fid(top_file_id, path)
+      raise 'file id shall be String' unless top_file_id.is_a?(String)
+      path_elements = path.split(PATH_SEPARATOR).reject(&:empty?)
+      return {api: self, file_id: top_file_id} if path_elements.empty?
+      resolve_state = {path: path_elements, result: nil}
+      process_folder_tree(state: resolve_state, method: :process_resolve_node_path, top_file_id: top_file_id)
+      raise "entry not found: #{resolve_state[:path]}" if resolve_state[:result].nil?
+      return resolve_state[:result]
+    end
+
+    # add entry to list if test block is success
+    def process_find_files(entry, path, state)
+      begin
+        # add to result if match filter
+        state[:found].push(entry.merge({'path' => path})) if state[:test_block].call(entry)
+        # process link
+        if entry[:type].eql?('link')
+          other_node = node_id_to_node(entry['target_node_id'])
+          other_node.process_folder_tree(state: state, method: process_find_files, top_file_id: entry['target_id'], top_file_path: path)
+        end
+      rescue StandardError => e
+        Log.log.error{"#{path}: #{e.message}"}
+      end
+      # process all folders
+      return true
+    end
+
+    def find_files(top_file_id, test_block)
+      Log.log.debug{"find_files: fileid=#{top_file_id}"}
+      find_state = {found: [], test_block: test_block}
+      process_folder_tree(state: find_state, method: :process_find_files, top_file_id: top_file_id)
+      return find_state[:found]
+    end
+
+    # Create transfer spec for gen4
+    def transfer_spec_gen4(file_id, direction, ts_merge=nil)
+      ak_name = nil
+      ak_token = nil
+      case params[:auth][:type]
+      when :basic
+        ak_name = params[:auth][:username]
+      when :oauth2
+        ak_name = params[:headers][X_ASPERA_ACCESSKEY]
+        token_generation_lambda = lambda{|do_refresh|oauth_token(force_refresh: do_refresh)}
+        ak_token = token_generation_lambda.call(false) # first time, use cache
+        @app_info[:plugin].transfer.token_regenerator = token_generation_lambda unless @app_info.nil?
+      else raise "Unsupported auth method for node gen4: #{params[:auth][:type]}"
+      end
+      transfer_spec = {
+        'direction' => direction,
+        'token'     => ak_token,
+        'tags'      => {
+          'aspera' => {
+            'node' => {
+              'access_key' => ak_name,
+              'file_id'    => file_id
+            } # node
+          } # aspera
+        } # tags
+      }
+      # add specials tags (cos)
+      add_tspec_info(transfer_spec)
+      transfer_spec.deep_merge!(ts_merge) unless ts_merge.nil?
+      # add application specific tags (AoC)
+      the_app = app_info
+      the_app[:api].add_ts_tags(transfer_spec: transfer_spec, app_info: the_app) unless the_app.nil?
+      # add basic token
+      if transfer_spec['token'].nil?
+        ts_basic_token(transfer_spec)
+      end
+      # add remote host info
+      if self.class.use_standard_ports
+        # get default TCP/UDP ports and transfer user
+        transfer_spec.merge!(Fasp::TransferSpec::AK_TSPEC_BASE)
+        # by default: same address as node API
+        transfer_spec['remote_host'] = URI.parse(params[:base_url]).host
+        if !@app_info.nil? && !@app_info[:node_info]['transfer_url'].nil? && !@app_info[:node_info]['transfer_url'].empty?
+          transfer_spec['remote_host'] = @app_info[:node_info]['transfer_url']
+        end
+      else
+        # retrieve values from API
+        std_t_spec = create(
+          'files/download_setup',
+          {transfer_requests: [{ transfer_request: {paths: [{'source' => '/'}] } }] }
+        )[:data]['transfer_specs'].first['transfer_spec']
+        # copy some parts
+        %w[remote_host remote_user ssh_port fasp_port wss_enabled wss_port].each {|i| transfer_spec[i] = std_t_spec[i] if std_t_spec.key?(i)}
+      end
+      return transfer_spec
+    end
+
+    # set basic token in transfer spec
+    def ts_basic_token(ts)
+      Log.log.warn{"Expected transfer user: #{Fasp::TransferSpec::ACCESS_KEY_TRANSFER_USER}, but have #{ts['remote_user']}"} \
+        unless ts['remote_user'].eql?(Fasp::TransferSpec::ACCESS_KEY_TRANSFER_USER)
+      raise 'ERROR: no secret in node object' unless params[:auth][:password]
+      ts['token'] = Rest.basic_creds(params[:auth][:username], params[:auth][:password])
     end
   end
 end

data/lib/aspera/oauth.rb

@@ -35,7 +35,7 @@ module Aspera
     # a prefix for persistency of tokens (simplify garbage collect)
     PERSIST_CATEGORY_TOKEN = 'token'
 
-    private_constant :JWT_NOTBEFORE_OFFSET_SEC,:JWT_EXPIRY_OFFSET_SEC,:TOKEN_CACHE_EXPIRY_SEC,:PERSIST_CATEGORY_TOKEN,:TOKEN_EXPIRATION_GUARD_SEC
+    private_constant :JWT_NOTBEFORE_OFFSET_SEC, :JWT_EXPIRY_OFFSET_SEC, :TOKEN_CACHE_EXPIRY_SEC, :PERSIST_CATEGORY_TOKEN, :TOKEN_EXPIRATION_GUARD_SEC
 
     # persistency manager
     @persist = nil
@@ -48,7 +48,7 @@ module Aspera
       def persist_mgr=(manager)
         @persist = manager
         # cleanup expired tokens
-        @persist.garbage_collect(PERSIST_CATEGORY_TOKEN,TOKEN_CACHE_EXPIRY_SEC)
+        @persist.garbage_collect(PERSIST_CATEGORY_TOKEN, TOKEN_CACHE_EXPIRY_SEC)
       end
 
       def persist_mgr
@@ -56,7 +56,7 @@ module Aspera
           Log.log.debug('Not using persistency') # (use Aspera::Oauth.persist_mgr=Aspera::PersistencyFolder.new)
           # create NULL persistency class
           @persist = Class.new do
-            def get(_x);nil;end;def delete(_x);nil;end;def put(_x,_y);nil;end;def garbage_collect(_x,_y);nil;end # rubocop:disable Layout/EmptyLineBetweenDefs
+            def get(_x); nil; end; def delete(_x); nil; end; def put(_x, _y); nil; end; def garbage_collect(_x, _y); nil; end # rubocop:disable Layout/EmptyLineBetweenDefs, Style/Semicolon, Layout/LineLength
           end.new
         end
         return @persist
@@ -64,7 +64,7 @@ module Aspera
 
       # delete all existing tokens
       def flush_tokens
-        persist_mgr.garbage_collect(PERSIST_CATEGORY_TOKEN,nil)
+        persist_mgr.garbage_collect(PERSIST_CATEGORY_TOKEN, nil)
       end
 
       # register a bearer token decoder, mainly to inspect expiry date
@@ -94,24 +94,24 @@ module Aspera
 
       # @return one of the registered creators for the given create type
       def token_creator(id)
-        raise "token creator type unknown: #{id}/#{id.class}" unless @create_handlers.has_key?(id)
+        raise "token creator type unknown: #{id}/#{id.class}" unless @create_handlers.key?(id)
         @create_handlers[id]
       end
 
       # list of identifiers foundn in creation parameters that can be used to uniquely identify the token
       def id_creator(id)
-        raise "id creator type unknown: #{id}/#{id.class}" unless @id_handlers.has_key?(id)
+        raise "id creator type unknown: #{id}/#{id.class}" unless @id_handlers.key?(id)
         @id_handlers[id]
       end
     end # self
 
     # JSON Web Signature (JWS) compact serialization: https://datatracker.ietf.org/doc/html/rfc7515
-    register_decoder lambda { |token| parts = token.split('.'); raise 'not aoc token' unless parts.length.eql?(3); JSON.parse(Base64.decode64(parts[1]))}
+    register_decoder lambda { |token| parts = token.split('.'); raise 'not aoc token' unless parts.length.eql?(3); JSON.parse(Base64.decode64(parts[1]))} # rubocop:disable Style/Semicolon, Layout/LineLength
 
     # generic token creation, parameters are provided in :generic
-    register_token_creator :generic,lambda { |oauth|
+    register_token_creator :generic, lambda { |oauth|
       return oauth.create_token(oauth.sparams)
-    },lambda { |oauth|
+    }, lambda { |oauth|
       return [
         oauth.sparams[:grant_type]&.split(':')&.last,
         oauth.sparams[:apikey],
@@ -120,12 +120,13 @@ module Aspera
     }
 
     # Authentication using Web browser
-    register_token_creator :web,lambda { |oauth|
+    register_token_creator :web, lambda { |oauth|
       random_state = SecureRandom.uuid # used to check later
-      login_page_url = Rest.build_uri("#{oauth.api[:base_url]}/#{oauth.sparams[:path_authorize]}",
+      login_page_url = Rest.build_uri(
+        "#{oauth.api.params[:base_url]}/#{oauth.sparams[:path_authorize]}",
         oauth.optional_scope_client_id.merge(response_type: 'code', redirect_uri: oauth.sparams[: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.info{"login_page_url=#{login_page_url}".bg_red.gray}
       # start a web server to receive request code
       webserver = WebAuth.new(oauth.sparams[:redirect_uri])
       # start browser on login page
@@ -138,17 +139,17 @@ module Aspera
         grant_type:   'authorization_code',
         code:         received_params['code'],
         redirect_uri: oauth.sparams[:redirect_uri]))
-    },lambda { |_oauth|
+    }, lambda { |_oauth|
       return []
     }
 
     # Authentication using private key
-    register_token_creator :jwt,lambda { |oauth|
+    register_token_creator :jwt, lambda { |oauth|
       # https://tools.ietf.org/html/rfc7523
       # https://tools.ietf.org/html/rfc7519
       require 'jwt'
       seconds_since_epoch = Time.new.to_i
-      Log.log.info("seconds=#{seconds_since_epoch}")
+      Log.log.info{"seconds=#{seconds_since_epoch}"}
       raise 'missing JWT payload' unless oauth.sparams[:payload].is_a?(Hash)
       jwt_payload = {
         exp: seconds_since_epoch + JWT_EXPIRY_OFFSET_SEC, # expiration time
@@ -156,14 +157,14 @@ module Aspera
         iat: seconds_since_epoch, # issued at
         jti: SecureRandom.uuid # JWT id
       }.merge(oauth.sparams[:payload])
-      Log.log.debug("JWT jwt_payload=[#{jwt_payload}]")
+      Log.log.debug{"JWT jwt_payload=[#{jwt_payload}]"}
       rsa_private = oauth.sparams[:private_key_obj] # type: OpenSSL::PKey::RSA
-      Log.log.debug("private=[#{rsa_private}]")
+      Log.log.debug{"private=[#{rsa_private}]"}
       assertion = JWT.encode(jwt_payload, rsa_private, 'RS256', oauth.sparams[:headers] || {})
-      Log.log.debug("assertion=[#{assertion}]")
+      Log.log.debug{"assertion=[#{assertion}]"}
       return oauth.create_token(oauth.optional_scope_client_id.merge(grant_type: 'urn:ietf:params:oauth:grant-type:jwt-bearer', assertion: assertion))
-    },lambda { |oauth|
-      return [oauth.sparams.dig(:payload,:sub)]
+    }, lambda { |oauth|
+      return [oauth.sparams.dig(:payload, :sub)]
     }
 
     attr_reader :gparams, :sparams, :api
@@ -186,14 +187,14 @@ module Aspera
     # :web:path_authorize  [D] for type :web
     # :generic             [M] for type :generic
     def initialize(a_params)
-      Log.log.debug("auth=#{a_params}")
+      Log.log.debug{"auth=#{a_params}"}
       # replace default values
       @gparams = DEFAULT_CREATE_PARAMS.deep_merge(a_params)
       # check that type is known
       self.class.token_creator(@gparams[:crtype])
       # specific parameters for the creation type
-      @sparams=@gparams[@gparams[:crtype]]
-      if @gparams[:crtype].eql?(:web) && @sparams.has_key?(:redirect_uri)
+      @sparams = @gparams[@gparams[:crtype]]
+      if @gparams[:crtype].eql?(:web) && @sparams.key?(:redirect_uri)
         uri = URI.parse(@sparams[:redirect_uri])
         raise 'redirect_uri scheme must be http or https' unless %w[http https].include?(uri.scheme)
         raise 'redirect_uri must have a port' if uri.port.nil?
@@ -203,14 +204,14 @@ module Aspera
         base_url:     @gparams[:base_url],
         redirect_max: 2
       }
-      rest_params[:auth] = a_params[:auth] if a_params.has_key?(:auth)
+      rest_params[:auth] = a_params[:auth] if a_params.key?(:auth)
       @api = Rest.new(rest_params)
       # if needed use from api
       @gparams.delete(:base_url)
       @gparams.delete(:auth)
       @gparams.delete(@gparams[:crtype])
-      Log.dump(:gparams,@gparams)
-      Log.dump(:sparams,@sparams)
+      Log.dump(:gparams, @gparams)
+      Log.dump(:sparams, @sparams)
     end
 
     public
@@ -226,7 +227,7 @@ module Aspera
 
     # @return Hash with optional general parameters
     def optional_scope_client_id(add_secret: false)
-      call_params={}
+      call_params = {}
       call_params[:scope] = @gparams[:scope] unless @gparams[:scope].nil?
       call_params[:client_id] = @gparams[:client_id] unless @gparams[:client_id].nil?
       call_params[:client_secret] = @gparams[:client_secret] if add_secret && !@gparams[:client_id].nil?
@@ -254,7 +255,7 @@ module Aspera
       # `direct` agent is equipped with refresh code
       if !use_refresh_token && !token_data.nil?
         decoded_token = self.class.decode_token(token_data[@gparams[:token_field]])
-        Log.dump('decoded_token',decoded_token) unless decoded_token.nil?
+        Log.dump('decoded_token', decoded_token) unless decoded_token.nil?
         if decoded_token.is_a?(Hash)
           expires_at_sec =
             if    decoded_token['expires_at'].is_a?(String) then DateTime.parse(decoded_token['expires_at']).to_time
@@ -262,13 +263,13 @@ module Aspera
             end
           # force refresh if we see a token too close from expiration
           use_refresh_token = true if expires_at_sec.is_a?(Time) && (expires_at_sec - Time.now) < TOKEN_EXPIRATION_GUARD_SEC
-          Log.log.debug("Expiration: #{expires_at_sec} / #{use_refresh_token}")
+          Log.log.debug{"Expiration: #{expires_at_sec} / #{use_refresh_token}"}
         end
       end
 
       # an API was already called, but failed, we need to regenerate or refresh
       if use_refresh_token
-        if token_data.is_a?(Hash) && token_data.has_key?('refresh_token')
+        if token_data.is_a?(Hash) && token_data.key?('refresh_token')
           # save possible refresh token, before deleting the cache
           refresh_token = token_data['refresh_token']
         end
@@ -277,17 +278,17 @@ module Aspera
         token_data = nil
         # lets try the existing refresh token
         if !refresh_token.nil?
-          Log.log.info("refresh=[#{refresh_token}]".bg_green)
+          Log.log.info{"refresh=[#{refresh_token}]".bg_green}
           # try to refresh
           # note: AoC admin token has no refresh, and lives by default 1800secs
-          resp = create_token(optional_scope_client_id.merge(grant_type: 'refresh_token',refresh_token: refresh_token))
+          resp = create_token(optional_scope_client_id.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
             token_data = JSON.parse(json_data)
-            self.class.persist_mgr.put(token_id,json_data)
+            self.class.persist_mgr.put(token_id, json_data)
           else
-            Log.log.debug("refresh failed: #{resp[:http].body}".bg_red)
+            Log.log.debug{"refresh failed: #{resp[:http].body}".bg_red}
           end
         end
       end
@@ -297,9 +298,9 @@ module Aspera
         resp = self.class.token_creator(@gparams[:crtype]).call(self)
         json_data = resp[:http].body
         token_data = JSON.parse(json_data)
-        self.class.persist_mgr.put(token_id,json_data)
+        self.class.persist_mgr.put(token_id, json_data)
       end # if ! in_cache
-      raise "API error: No such field in answer: #{@gparams[:token_field]}" unless token_data.has_key?(@gparams[:token_field])
+      raise "API error: No such field in answer: #{@gparams[:token_field]}" unless token_data.key?(@gparams[:token_field])
       # ok we shall have a token here
       return 'Bearer ' + token_data[@gparams[:token_field]]
     end

data/lib/aspera/open_application.rb

@@ -12,30 +12,38 @@ module Aspera
   class OpenApplication
     include Singleton
     class << self
+      USER_INTERFACES = %i[text graphical].freeze
       # User Interfaces
-      def user_interfaces; %i[text graphical]; end
+      def user_interfaces; USER_INTERFACES; end
 
       def default_gui_mode
-        return :graphical if [Aspera::Environment::OS_WINDOWS,Aspera::Environment::OS_X].include?(Aspera::Environment.os)
+        return :graphical if [Aspera::Environment::OS_WINDOWS, Aspera::Environment::OS_X].include?(Aspera::Environment.os)
         # unix family
-        return :graphical if ENV.has_key?('DISPLAY') && !ENV['DISPLAY'].empty?
+        return :graphical if ENV.key?('DISPLAY') && !ENV['DISPLAY'].empty?
         return :text
       end
 
       # command must be non blocking
       def uri_graphical(uri)
         case Aspera::Environment.os
-        when Aspera::Environment::OS_X
-          return system('open',uri.to_s)
-        when Aspera::Environment::OS_WINDOWS
-          return system('start explorer "' + uri.to_s + '"')
-        when Aspera::Environment::OS_LINUX
-          return system("xdg-open '#{uri}'")
+        when Aspera::Environment::OS_X       then return system('open', uri.to_s)
+        when Aspera::Environment::OS_WINDOWS then return system('start', 'explorer', '"' + uri.to_s + '"')
+        when Aspera::Environment::OS_LINUX   then return system('xdg-open', uri.to_s)
         else
           raise "no graphical open method for #{Aspera::Environment.os}"
         end
       end
-    end
+
+      def editor(file_path)
+        if ENV.key?('EDITOR')
+          system(ENV['EDITOR'], file_path.to_s)
+        elsif Aspera::Environment.os.eql?(Aspera::Environment::OS_WINDOWS)
+          system('notepad.exe', '"' + file_path.to_s + '"')
+        else
+          uri_graphical(file_path.to_s)
+        end
+      end
+    end # self
 
     attr_accessor :url_method
 
@@ -56,7 +64,7 @@ module Aspera
           puts "USER ACTION: open this:\n" + the_url.to_s.red + "\n"
         end
       else
-        raise StandardError,"unsupported url open method: #{@url_method}"
+        raise StandardError, "unsupported url open method: #{@url_method}"
       end
     end
   end # OpenApplication

data/lib/aspera/persistency_action_once.rb

@@ -14,7 +14,7 @@ module Aspera
     # @param :format   Optional  dump method (default to JSON)
     # @param :merge    Optional  merge data from file to current data
     def initialize(options)
-      Log.log.debug("persistency: #{options}")
+      Log.log.debug{"persistency: #{options}"}
       raise 'options shall be Hash' unless options.is_a?(Hash)
       raise 'mandatory :manager' if options[:manager].nil?
       raise 'mandatory :data' if options[:data].nil?
@@ -27,16 +27,16 @@ module Aspera
       @delete_condition = options[:delete] || lambda{|d|d.empty?}
       @persist_format = options[:format] || lambda {|h| JSON.generate(h)}
       persist_parse = options[:parse] || lambda {|t| JSON.parse(t)}
-      persist_merge = options[:merge] || lambda {|current,file| current.concat(file).uniq rescue current}
+      persist_merge = options[:merge] || lambda {|current, file| current.concat(file).uniq rescue current}
       value = @manager.get(@object_id)
-      persist_merge.call(@persisted_object,persist_parse.call(value)) unless value.nil?
+      persist_merge.call(@persisted_object, persist_parse.call(value)) unless value.nil?
     end
 
     def save
       if @delete_condition.call(@persisted_object)
         @manager.delete(@object_id)
       else
-        @manager.put(@object_id,@persist_format.call(@persisted_object))
+        @manager.put(@object_id, @persist_format.call(@persisted_object))
       end
     end
 

data/lib/aspera/persistency_folder.rb

@@ -14,17 +14,17 @@ module Aspera
     def initialize(folder)
       @cache = {}
       @folder = folder
-      Log.log.debug("persistency folder: #{@folder}")
+      Log.log.debug{"persistency folder: #{@folder}"}
     end
 
     # @return String or nil string on existing persist, else nil
     def get(object_id)
-      Log.log.debug("persistency get: #{object_id}")
-      if @cache.has_key?(object_id)
+      Log.log.debug{"persistency get: #{object_id}"}
+      if @cache.key?(object_id)
         Log.log.debug('got from memory cache')
       else
         persist_filepath = id_to_filepath(object_id)
-        Log.log.debug("persistency = #{persist_filepath}")
+        Log.log.debug{"persistency = #{persist_filepath}"}
         if File.exist?(persist_filepath)
           Log.log.debug('got from file cache')
           @cache[object_id] = File.read(persist_filepath)
@@ -33,32 +33,32 @@ module Aspera
       return @cache[object_id]
     end
 
-    def put(object_id,value)
+    def put(object_id, value)
       raise 'value: only String supported' unless value.is_a?(String)
       persist_filepath = id_to_filepath(object_id)
-      Log.log.debug("persistency saving: #{persist_filepath}")
+      Log.log.debug{"persistency saving: #{persist_filepath}"}
       File.delete(persist_filepath) if File.exist?(persist_filepath)
-      File.write(persist_filepath,value)
+      File.write(persist_filepath, value)
       Environment.restrict_file_access(persist_filepath)
       @cache[object_id] = value
     end
 
     def delete(object_id)
       persist_filepath = id_to_filepath(object_id)
-      Log.log.debug("persistency deleting: #{persist_filepath}")
+      Log.log.debug{"persistency deleting: #{persist_filepath}"}
       File.delete(persist_filepath) if File.exist?(persist_filepath)
       @cache.delete(object_id)
     end
 
-    def garbage_collect(persist_category,max_age_seconds=nil)
-      garbage_files = Dir[File.join(@folder,persist_category + '*' + FILE_SUFFIX)]
+    def garbage_collect(persist_category, max_age_seconds=nil)
+      garbage_files = Dir[File.join(@folder, persist_category + '*' + FILE_SUFFIX)]
       if !max_age_seconds.nil?
         current_time = Time.now
         garbage_files.select! { |filepath| (current_time - File.stat(filepath).mtime).to_i > max_age_seconds}
       end
       garbage_files.each do |filepath|
         File.delete(filepath)
-        Log.log.debug("persistency deleted expired: #{filepath}")
+        Log.log.debug{"persistency deleted expired: #{filepath}"}
       end
       return garbage_files
     end
@@ -70,8 +70,8 @@ module Aspera
       raise 'object_id: only String supported' unless object_id.is_a?(String)
       FileUtils.mkdir_p(@folder)
       Environment.restrict_file_access(@folder)
-      return File.join(@folder,"#{object_id}#{FILE_SUFFIX}")
-      #.gsub(/[^a-z]+/,FILE_FIELD_SEPARATOR)
+      return File.join(@folder, "#{object_id}#{FILE_SUFFIX}")
+      # .gsub(/[^a-z]+/,FILE_FIELD_SEPARATOR)
     end
   end # PersistencyFolder
 end # Aspera