aspera-cli 4.7.0 → 4.8.0

data/lib/aspera/ascmd.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'aspera/log'
 
 module Aspera
@@ -8,7 +9,7 @@ module Aspera
   # Note: "ls" can take filters: as_ls -f *.txt -f *.bin /
   class AsCmd
     # list of supported actions
-    OPERATIONS=[:ls,:rm,:mv,:du,:info,:mkdir,:cp,:df,:md5sum].freeze
+    OPERATIONS = %i[ls rm mv du info mkdir cp df md5sum].freeze
 
     #  @param command_executor [Object] provides the "execute" method, taking a command to execute, and stdin to feed to it, typically: ssh or local
     def initialize(command_executor)
@@ -21,37 +22,38 @@ module Aspera
     # @return result of command, type depends on command (bool, array, hash)
     def execute_single(action_sym,args=nil)
       # concatenate arguments, enclose in double quotes, protect backslash and double quotes, add "as_" command and as_exit
-      stdin_input=(args||[]).map{|v| '"' + v.gsub(/["\\]/n) {|s| '\\' + s } + '"'}.unshift('as_'+action_sym.to_s).join(' ')+"\nas_exit\n"
+      stdin_input = (args || []).map{|v| '"' + v.gsub(/["\\]/n) {|s| '\\' + s } + '"'}.unshift('as_' + action_sym.to_s).join(' ') + "\nas_exit\n"
       # execute, get binary output
-      bytebuffer=@command_executor.execute('ascmd',stdin_input).unpack('C*')
+      bytebuffer = @command_executor.execute('ascmd',stdin_input).unpack('C*')
       # get hash or table result
-      result=self.class.parse(bytebuffer,:result)
+      result = self.class.parse(bytebuffer,:result)
       raise 'ERROR: unparsed bytes remaining' unless bytebuffer.empty?
       # get and delete info,always present in results
-      system_info=result[:info]
+      system_info = result[:info]
       result.delete(:info)
       # make single file result like a folder
-      if result.has_key?(:file);result[:dir]=[result[:file]];result.delete(:file);end
+      if result.has_key?(:file);result[:dir] = [result[:file]];result.delete(:file);end
       # add type field for stats
       if result.has_key?(:dir)
         result[:dir].each do |file|
           if file.has_key?(:smode)
             # Converts the first character of the file mode (see 'man ls') into a type.
-            file[:type]=case file[:smode][0,1];when 'd' then:directory;when '-' then:file;when 'l' then:link;else;:other;end
+            file[:type] = case file[:smode][0,1];when 'd' then:directory;when '-' then:file;when 'l' then:link;else;:other;end
           end
         end
       end
       # for info, second overrides first, so restore it
-      case result.keys.length;when 0 then result=system_info;when 1 then result=result[result.keys.first];else raise 'error';end
+      case result.keys.length;when 0 then result = system_info;when 1 then result = result[result.keys.first];else raise 'error';end
       # raise error as exception
-      raise Error.new(result[:errno],result[:errstr],action_sym,args) if result.is_a?(Hash) && (result.keys.sort == TYPES_DESCR[:error][:fields].map{|i|i[:name]}.sort)
+      raise Error.new(result[:errno],result[:errstr],action_sym,args) if
+        result.is_a?(Hash) && (result.keys.sort == TYPES_DESCR[:error][:fields].map{|i|i[:name]}.sort)
       return result
     end # execute_single
 
     # This exception is raised when +ascmd+ returns an error.
     class Error < StandardError
       attr_reader :errno, :errstr, :command, :args
-      def initialize(errno,errstr,cmd,args);super();@errno=errno;@errstr=errstr;@command=cmd;@args=args;end
+      def initialize(errno,errstr,cmd,args);super();@errno = errno;@errstr = errstr;@command = cmd;@args = args;end
 
       def message; "ascmd: (#{errno}) #{errstr}"; end
 
@@ -60,22 +62,31 @@ module Aspera
 
     # description of result structures (see ascmdtypes.h). Base types are big endian
     # key = name of type
-    TYPES_DESCR={
+    TYPES_DESCR = {
       result: {decode: :field_list,
-fields: [{name: :file,is_a: :stat},{name: :dir,is_a: :stat,special: :substruct},{name: :size,is_a: :size},{name: :error,is_a: :error},{name: :info,is_a: :info},
-         {name: :success,is_a: nil,special: :return_true},{name: :exit,is_a: nil},{name: :df,is_a: :mnt,special: :restart_on_first},{name: :md5sum,is_a: :md5sum}]},
+               fields: [{name: :file,is_a: :stat},{name: :dir,is_a: :stat,special: :substruct},{name: :size,is_a: :size},{name: :error,is_a: :error},
+                        {name: :info,is_a: :info},{name: :success,is_a: nil,special: :return_true},{name: :exit,is_a: nil},
+                        {name: :df,is_a: :mnt,special: :restart_on_first},{name: :md5sum,is_a: :md5sum}]},
       stat:   {decode: :field_list,
-fields: [{name: :name,is_a: :zstr},{name: :size,is_a: :int64},{name: :mode,is_a: :int32,check: nil},{name: :zmode,is_a: :zstr},{name: :uid,is_a: :int32,check: nil},
-         {name: :zuid,is_a: :zstr},{name: :gid,is_a: :int32,check: nil},{name: :zgid,is_a: :zstr},{name: :ctime,is_a: :epoch},{name: :zctime,is_a: :zstr},{name: :mtime,is_a: :epoch},{name: :zmtime,is_a: :zstr},{name: :atime,is_a: :epoch},{name: :zatime,is_a: :zstr},{name: :symlink,is_a: :zstr},{name: :errno,is_a: :int32},{name: :errstr,is_a: :zstr}]},
+               fields: [{name: :name,is_a: :zstr},{name: :size,is_a: :int64},{name: :mode,is_a: :int32,check: nil},{name: :zmode,is_a: :zstr},
+                        {name: :uid,is_a: :int32,check: nil},{name: :zuid,is_a: :zstr},{name: :gid,is_a: :int32,check: nil},{name: :zgid,is_a: :zstr},
+                        {name: :ctime,is_a: :epoch},{name: :zctime,is_a: :zstr},{name: :mtime,is_a: :epoch},{name: :zmtime,is_a: :zstr},
+                        {name: :atime,is_a: :epoch},{name: :zatime,is_a: :zstr},{name: :symlink,is_a: :zstr},{name: :errno,is_a: :int32},
+                        {name: :errstr,is_a: :zstr}]},
       info:   {decode: :field_list,
-fields: [{name: :platform,is_a: :zstr},{name: :version,is_a: :zstr},{name: :lang,is_a: :zstr},{name: :territory,is_a: :zstr},{name: :codeset,is_a: :zstr},
-         {name: :lc_ctype,is_a: :zstr},{name: :lc_numeric,is_a: :zstr},{name: :lc_time,is_a: :zstr},{name: :lc_all,is_a: :zstr},{name: :dev,is_a: :zstr,special: :multiple},{name: :browse_caps,is_a: :zstr},{name: :protocol,is_a: :zstr}]},
+               fields: [{name: :platform,is_a: :zstr},{name: :version,is_a: :zstr},{name: :lang,is_a: :zstr},{name: :territory,is_a: :zstr},
+                        {name: :codeset,is_a: :zstr},{name: :lc_ctype,is_a: :zstr},{name: :lc_numeric,is_a: :zstr},{name: :lc_time,is_a: :zstr},
+                        {name: :lc_all,is_a: :zstr},{name: :dev,is_a: :zstr,special: :multiple},{name: :browse_caps,is_a: :zstr},
+                        {name: :protocol,is_a: :zstr}]},
       size:   {decode: :field_list,
-fields: [{name: :size,is_a: :int64},{name: :fcount,is_a: :int32},{name: :dcount,is_a: :int32},{name: :failed_fcount,is_a: :int32},{name: :failed_dcount,is_a: :int32}]},
-      error:  {decode: :field_list,fields: [{name: :errno,is_a: :int32},{name: :errstr,is_a: :zstr}]},
+               fields: [{name: :size,is_a: :int64},{name: :fcount,is_a: :int32},{name: :dcount,is_a: :int32},{name: :failed_fcount,is_a: :int32},
+                        {name: :failed_dcount,is_a: :int32}]},
+      error:  {decode: :field_list,
+               fields: [{name: :errno,is_a: :int32},{name: :errstr,is_a: :zstr}]},
       mnt:    {decode: :field_list,
-fields: [{name: :fs,is_a: :zstr},{name: :dir,is_a: :zstr},{name: :is_a,is_a: :zstr},{name: :total,is_a: :int64},{name: :used,is_a: :int64},{name: :free,is_a: :int64},
-         {name: :fcount,is_a: :int64},{name: :errno,is_a: :int32},{name: :errstr,is_a: :zstr}]},
+               fields: [{name: :fs,is_a: :zstr},{name: :dir,is_a: :zstr},{name: :is_a,is_a: :zstr},{name: :total,is_a: :int64},
+                        {name: :used,is_a: :int64},{name: :free,is_a: :int64},{name: :fcount,is_a: :int64},{name: :errno,is_a: :int32},
+                        {name: :errstr,is_a: :zstr}]},
       md5sum: {decode: :field_list,fields: [{name: :md5sum,is_a: :zstr}]},
       int8:   {decode: :base,unpack: 'C',size: 1},
       int32:  {decode: :base,unpack: 'L>',size: 4},
@@ -86,14 +97,14 @@ fields: [{name: :fs,is_a: :zstr},{name: :dir,is_a: :zstr},{name: :is_a,is_a: :zs
     }.freeze
 
     # protocol enum start at one, but array index start at zero
-    ENUM_START=1
+    ENUM_START = 1
 
     private_constant :TYPES_DESCR,:ENUM_START
 
     class << self
       # get description of structure's field, @param struct_name, @param typed_buffer provides field name
       def field_description(struct_name,typed_buffer)
-        result=TYPES_DESCR[struct_name][:fields][typed_buffer[:btype]-ENUM_START]
+        result = TYPES_DESCR[struct_name][:fields][typed_buffer[:btype] - ENUM_START]
         raise "Unrecognized field for #{struct_name}: #{typed_buffer[:btype]}\n#{typed_buffer[:buffer]}" if result.nil?
         return result
       end
@@ -102,28 +113,28 @@ fields: [{name: :fs,is_a: :zstr},{name: :dir,is_a: :zstr},{name: :is_a,is_a: :zs
       # @return a decoded type.
       # :base : value, :buffer_list : an array of {btype,buffer}, :field_list : a hash, or array
       def parse(buffer,type_name,indent_level=nil)
-        indent_level=(indent_level||-1)+1
-        type_descr=TYPES_DESCR[type_name]
+        indent_level = (indent_level || -1) + 1
+        type_descr = TYPES_DESCR[type_name]
         raise "Unexpected type #{type_name}" if type_descr.nil?
-        Log.log.debug("#{'   .'*indent_level}parse:#{type_name}:#{type_descr[:decode]}:#{buffer[0,16]}...".red)
-        result=nil
+        Log.log.debug("#{'   .' * indent_level}parse:#{type_name}:#{type_descr[:decode]}:#{buffer[0,16]}...".red)
+        result = nil
         case type_descr[:decode]
         when :base
-          num_bytes=type_name.eql?(:zstr) ? buffer.length : type_descr[:size]
+          num_bytes = type_name.eql?(:zstr) ? buffer.length : type_descr[:size]
           raise 'ERROR:not enough bytes' if buffer.length < num_bytes
-          byte_array=buffer.shift(num_bytes);byte_array=[byte_array] unless byte_array.is_a?(Array)
-          result=byte_array.pack('C*').unpack1(type_descr[:unpack])
-          Log.log.debug("#{'   .'*indent_level}-> base:#{byte_array} -> #{result}")
-          result=Time.at(result) if type_name.eql?(:epoch)
+          byte_array = buffer.shift(num_bytes);byte_array = [byte_array] unless byte_array.is_a?(Array)
+          result = byte_array.pack('C*').unpack1(type_descr[:unpack])
+          Log.log.debug("#{'   .' * indent_level}-> base:#{byte_array} -> #{result}")
+          result = Time.at(result) if type_name.eql?(:epoch)
         when :buffer_list
           result = []
           while !buffer.empty?
-            btype=parse(buffer,:int8,indent_level)
-            length=parse(buffer,:int32,indent_level)
+            btype = parse(buffer,:int8,indent_level)
+            length = parse(buffer,:int32,indent_level)
             raise 'ERROR:not enough bytes' if buffer.length < length
-            value=buffer.shift(length)
+            value = buffer.shift(length)
             result.push({btype: btype,buffer: value})
-            Log.log.debug("#{'   .'*indent_level}:buffer_list[#{result.length-1}] #{result.last}")
+            Log.log.debug("#{'   .' * indent_level}:buffer_list[#{result.length - 1}] #{result.last}")
           end
         when :field_list
           # by default the result is one struct
@@ -131,24 +142,24 @@ fields: [{name: :fs,is_a: :zstr},{name: :dir,is_a: :zstr},{name: :is_a,is_a: :zs
           # get individual binary fields
           parse(buffer,:blist,indent_level).each do |typed_buffer|
             # what type of field is it ?
-            field_info=field_description(type_name,typed_buffer)
-            Log.log.debug("#{'   .'*indent_level}+ field(special=#{field_info[:special]})=#{field_info[:name]}".green)
+            field_info = field_description(type_name,typed_buffer)
+            Log.log.debug("#{'   .' * indent_level}+ field(special=#{field_info[:special]})=#{field_info[:name]}".green)
             case field_info[:special]
             when nil
-              result[field_info[:name]]=parse(typed_buffer[:buffer],field_info[:is_a],indent_level)
+              result[field_info[:name]] = parse(typed_buffer[:buffer],field_info[:is_a],indent_level)
             when :return_true
-              result[field_info[:name]]=true
+              result[field_info[:name]] = true
             when :substruct
-              result[field_info[:name]]=parse(typed_buffer[:buffer],:blist,indent_level).map{|r|parse(r[:buffer],field_info[:is_a],indent_level)}
+              result[field_info[:name]] = parse(typed_buffer[:buffer],:blist,indent_level).map{|r|parse(r[:buffer],field_info[:is_a],indent_level)}
             when :multiple
-              result[field_info[:name]]||=[]
+              result[field_info[:name]] ||= []
               result[field_info[:name]].push(parse(typed_buffer[:buffer],field_info[:is_a],indent_level))
             when :restart_on_first
-              fl=result[field_info[:name]]=[]
+              fl = result[field_info[:name]] = []
               parse(typed_buffer[:buffer],:blist,indent_level).map do |tb|
                 fl.push({}) if tb[:btype].eql?(ENUM_START)
-                fi=field_description(field_info[:is_a],tb)
-                fl.last[fi[:name]]=parse(tb[:buffer],fi[:is_a],indent_level)
+                fi = field_description(field_info[:is_a],tb)
+                fl.last[fi[:name]] = parse(tb[:buffer],fi[:is_a],indent_level)
               end
             end
           end

data/lib/aspera/ats_api.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'aspera/log'
 require 'aspera/rest'
 
@@ -6,23 +7,23 @@ module Aspera
   class AtsApi < Rest
     # currently supported clouds
     # Note to Aspera: shall be an API call
-    CLOUD_NAME={
+    CLOUD_NAME = {
       aws:       'Amazon Web Services',
       azure:     'Microsoft Azure',
       google:    'Google Cloud',
       limelight: 'Limelight',
       rackspace: 'Rackspace',
       softlayer: 'IBM Cloud'
-    }
+    }.freeze
 
     private_constant :CLOUD_NAME
 
     def self.base_url;'https://ats.aspera.io';end
 
     def initialize
-      super({base_url: AtsApi.base_url+'/pub/v1'})
+      super({base_url: AtsApi.base_url + '/pub/v1'})
       # cache of server data
-      @all_servers_cache=nil
+      @all_servers_cache = nil
     end
 
     def cloud_names;CLOUD_NAME;end
@@ -31,7 +32,7 @@ module Aspera
     # NOTE to Aspera: an API shall be created to retrieve all servers at once
     def all_servers
       if @all_servers_cache.nil?
-        @all_servers_cache=[]
+        @all_servers_cache = []
         CLOUD_NAME.keys.each do |name|
           read("servers/#{name.to_s.upcase}")[:data].each do |i|
             @all_servers_cache.push(i)

data/lib/aspera/cli/basic_auth_plugin.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'aspera/rest'
 require 'aspera/cli/plugin'
 
@@ -6,30 +7,31 @@ module Aspera
   module Cli
     # base class for applications supporting basic authentication
     class BasicAuthPlugin < Plugin
+      class << self
+        def register_options(env)
+          env[:options].add_opt_simple(:url,'URL of application, e.g. https://org.asperafiles.com')
+          env[:options].add_opt_simple(:username,'username to log in')
+          env[:options].add_opt_simple(:password,"user's password")
+          env[:options].parse_options!
+        end
+      end
+
       def initialize(env)
         super(env)
         return if env[:skip_basic_auth_options]
-        options.add_opt_simple(:url,'URL of application, e.g. https://org.asperafiles.com')
-        options.add_opt_simple(:username,'username to log in')
-        options.add_opt_simple(:password,"user's password")
-        options.parse_options!
-      end
-      ACTIONS=[]
-
-      def execute_action
-        raise 'do not execute action on this generic plugin'
+        self.class.register_options(env)
       end
 
       # returns a Rest object with basic auth
       def basic_auth_api(subpath=nil)
-        api_url=options.get_option(:url,:mandatory)
-        api_url=api_url+'/'+subpath unless subpath.nil?
+        api_url = options.get_option(:url,is_type: :mandatory)
+        api_url = api_url + '/' + subpath unless subpath.nil?
         return Rest.new({
-          base_url:  api_url,
-          auth:      {
-          type:      :basic,
-          username:  options.get_option(:username,:mandatory),
-          password:  options.get_option(:password,:mandatory)
+          base_url: api_url,
+          auth:     {
+            type:     :basic,
+            username: options.get_option(:username,is_type: :mandatory),
+            password: options.get_option(:password,is_type: :mandatory)
           }})
       end
     end # BasicAuthPlugin

data/lib/aspera/cli/extended_value.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
+
 require 'aspera/cli/plugins/config'
 require 'aspera/uri_reader'
+require 'aspera/environment'
 require 'json'
 require 'base64'
 require 'zlib'
@@ -13,18 +15,18 @@ module Aspera
     class ExtendedValue
       include Singleton
 
-      class<<self
+      class << self
         # decode comma separated table text
-        def self.decode_csvt(value)
-          col_titles=nil
-          hasharray=[]
+        def decode_csvt(value)
+          col_titles = nil
+          hasharray = []
           CSV.parse(value).each do |values|
             next if values.empty?
             if col_titles.nil?
-              col_titles=values
+              col_titles = values
             else
-              entry={}
-              col_titles.each{|title|entry[title]=values.shift}
+              entry = {}
+              col_titles.each{|title|entry[title] = values.shift}
               hasharray.push(entry)
             end
           end
@@ -35,23 +37,23 @@ module Aspera
       private
 
       def initialize
-        @handlers={
+        @handlers = {
           decoder: {
-          base64:  lambda{|v|Base64.decode64(v)},
-          json:    lambda{|v|JSON.parse(v)},
-          zlib:    lambda{|v|Zlib::Inflate.inflate(v)},
-          ruby:    lambda{|v|eval(v)},
-          csvt:    lambda{|v|ExtendedValue.decode_csvt(v)},
-          lines:   lambda{|v|v.split("\n")},
-          list:    lambda{|v|v[1..-1].split(v[0])}
+            base64: lambda{|v|Base64.decode64(v)},
+            json:   lambda{|v|JSON.parse(v)},
+            zlib:   lambda{|v|Zlib::Inflate.inflate(v)},
+            ruby:   lambda{|v|Environment.secure_eval(v)},
+            csvt:   lambda{|v|ExtendedValue.decode_csvt(v)},
+            lines:  lambda{|v|v.split("\n")},
+            list:   lambda{|v|v[1..-1].split(v[0])}
           },
-          reader: {
-          val:     lambda{|v|v},
-          file:    lambda{|v|File.read(File.expand_path(v))},
-          path:    lambda{|v|File.expand_path(v)},
-          env:     lambda{|v|ENV[v]},
-          uri:     lambda{|v|UriReader.read(v)},
-          stdin:   lambda{|v|raise 'no value allowed for stdin' unless v.empty?;$stdin.read}
+          reader:  {
+            val:   lambda{|v|v},
+            file:  lambda{|v|File.read(File.expand_path(v))},
+            path:  lambda{|v|File.expand_path(v)},
+            env:   lambda{|v|ENV[v]},
+            uri:   lambda{|v|UriReader.read(v)},
+            stdin: lambda{|v|raise 'no value allowed for stdin' unless v.empty?;$stdin.read}
           }
           # other handlers can be set using set_handler, e.g. preset is reader in config plugin
         }
@@ -66,8 +68,8 @@ module Aspera
       def set_handler(name,type,method)
         Log.log.debug("setting #{type} handler for #{name}")
         raise 'name must be Symbol' unless name.is_a?(Symbol)
-        raise "type #{type} must be one of #{@handlers.keys}" unless @handlers.keys.include?(type)
-        @handlers[type][name]=method
+        raise "type #{type} must be one of #{@handlers.keys}" unless @handlers.key?(type)
+        @handlers[type][name] = method
       end
 
       # parse an option value if it is a String using supported extended value modifiers
@@ -75,20 +77,20 @@ module Aspera
       def evaluate(value)
         return value if !value.is_a?(String)
         # first determine decoders, in reversed order
-        decoders_reversed=[]
-        while (m=value.match(/^@([^:]+):(.*)/)) && @handlers[:decoder].include?(m[1].to_sym)
+        decoders_reversed = []
+        while (m = value.match(/^@([^:]+):(.*)/)) && @handlers[:decoder].include?(m[1].to_sym)
           decoders_reversed.unshift(m[1].to_sym)
-          value=m[2]
+          value = m[2]
         end
         # then read value
         @handlers[:reader].each do |reader,method|
-          if (m=value.match(/^@#{reader}:(.*)/))
-            value=method.call(m[1])
+          if (m = value.match(/^@#{reader}:(.*)/))
+            value = method.call(m[1])
             break
           end
         end
         decoders_reversed.each do |decoder|
-          value=@handlers[:decoder][decoder].call(value)
+          value = @handlers[:decoder][decoder].call(value)
         end
         return value
       end # parse