aspera-cli 4.6.0 → 4.7.0

data/lib/aspera/ascmd.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'aspera/log'
 
 module Aspera
@@ -7,7 +8,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]
+    OPERATIONS=[: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)
@@ -25,7 +26,7 @@ module Aspera
       bytebuffer=@command_executor.execute('ascmd',stdin_input).unpack('C*')
       # get hash or table result
       result=self.class.parse(bytebuffer,:result)
-      raise "ERROR: unparsed bytes remaining" unless bytebuffer.empty?
+      raise 'ERROR: unparsed bytes remaining' unless bytebuffer.empty?
       # get and delete info,always present in results
       system_info=result[:info]
       result.delete(:info)
@@ -36,38 +37,45 @@ module Aspera
         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';:directory;when'-';:file;when'l';: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;result=system_info;when 1;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) and 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);@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
 
       def extended_message; "ascmd: errno=#{errno} errstr=\"#{errstr}\" command=\"#{command}\" args=#{args}"; end
     end # Error
 
-    private
-
     # description of result structures (see ascmdtypes.h). Base types are big endian
     # key = name of type
     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}]},
-      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}]},
-      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}]},
-      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}]},
+      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}]},
+      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}]},
+      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}]},
+      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}]},
-      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}]},
+      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}]},
       md5sum: {decode: :field_list,fields: [{name: :md5sum,is_a: :zstr}]},
       int8:   {decode: :base,unpack: 'C',size: 1},
       int32:  {decode: :base,unpack: 'L>',size: 4},
@@ -75,77 +83,79 @@ module Aspera
       epoch:  {decode: :base,unpack: 'Q>',size: 8},
       zstr:   {decode: :base,unpack: 'Z*'},
       blist:  {decode: :buffer_list}
-    }
+    }.freeze
 
     # protocol enum start at one, but array index start at zero
     ENUM_START=1
 
     private_constant :TYPES_DESCR,:ENUM_START
 
-    # get description of structure's field, @param struct_name, @param typed_buffer provides field name
-    def self.field_description(struct_name,typed_buffer)
-      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
+    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]
+        raise "Unrecognized field for #{struct_name}: #{typed_buffer[:btype]}\n#{typed_buffer[:buffer]}" if result.nil?
+        return result
+      end
 
-    # decodes the provided buffer as provided type name
-    # @return a decoded type.
-    # :base : value, :buffer_list : an array of {btype,buffer}, :field_list : a hash, or array
-    def self.parse(buffer,type_name,indent_level=nil)
-      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
-      case type_descr[:decode]
-      when :base
-        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*').unpack(type_descr[:unpack]).first
-        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)
-          raise "ERROR:not enough bytes" if buffer.length < length
-          value=buffer.shift(length)
-          result.push({btype: btype,buffer: value})
-          Log.log.debug("#{"   ."*indent_level}:buffer_list[#{result.length-1}] #{result.last}")
-        end
-      when :field_list
-        # by default the result is one struct
-        result = {}
-        # 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)
-          case field_info[:special]
-          when nil
-            result[field_info[:name]]=parse(typed_buffer[:buffer],field_info[:is_a],indent_level)
-          when :return_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)}
-          when :multiple
-            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]]=[]
-            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)
+      # decodes the provided buffer as provided type name
+      # @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]
+        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
+        case type_descr[:decode]
+        when :base
+          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)
+        when :buffer_list
+          result = []
+          while !buffer.empty?
+            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)
+            result.push({btype: btype,buffer: value})
+            Log.log.debug("#{'   .'*indent_level}:buffer_list[#{result.length-1}] #{result.last}")
+          end
+        when :field_list
+          # by default the result is one struct
+          result = {}
+          # 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)
+            case field_info[:special]
+            when nil
+              result[field_info[:name]]=parse(typed_buffer[:buffer],field_info[:is_a],indent_level)
+            when :return_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)}
+            when :multiple
+              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]]=[]
+              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)
+              end
             end
           end
-        end
-      else raise "error: unknown decode:#{type_descr[:decode]}"
-      end # is_a
-      return result
+        else raise "error: unknown decode:#{type_descr[:decode]}"
+        end # is_a
+        return result
+      end
     end
   end
 end

data/lib/aspera/ats_api.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'aspera/log'
 require 'aspera/rest'
 
@@ -6,24 +7,24 @@ module Aspera
     # currently supported clouds
     # Note to Aspera: shall be an API call
     CLOUD_NAME={
-      :aws =>'Amazon Web Services',
-      :azure =>'Microsoft Azure',
-      :google =>'Google Cloud',
-      :limelight =>'Limelight',
-      :rackspace =>'Rackspace',
-      :softlayer =>'IBM Cloud'
+      aws:       'Amazon Web Services',
+      azure:     'Microsoft Azure',
+      google:    'Google Cloud',
+      limelight: 'Limelight',
+      rackspace: 'Rackspace',
+      softlayer: 'IBM Cloud'
     }
-    
+
     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
     end
-    
+
     def cloud_names;CLOUD_NAME;end
 
     # all available ATS servers

data/lib/aspera/cli/basic_auth_plugin.rb

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

data/lib/aspera/cli/extended_value.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
 require 'aspera/cli/plugins/config'
+require 'aspera/uri_reader'
 require 'json'
 require 'base64'
 require 'zlib'
@@ -10,54 +12,61 @@ module Aspera
     # command line extended values
     class ExtendedValue
       include Singleton
-      private
-      # decode comma separated table text
-      def self.decode_csvt(value)
-        col_titles=nil
-        hasharray=[]
-        CSV.parse(value).each do |values|
-          next if values.empty?
-          if col_titles.nil?
-            col_titles=values
-          else
-            entry={}
-            col_titles.each{|title|entry[title]=values.shift}
-            hasharray.push(entry)
+
+      class<<self
+        # decode comma separated table text
+        def self.decode_csvt(value)
+          col_titles=nil
+          hasharray=[]
+          CSV.parse(value).each do |values|
+            next if values.empty?
+            if col_titles.nil?
+              col_titles=values
+            else
+              entry={}
+              col_titles.each{|title|entry[title]=values.shift}
+              hasharray.push(entry)
+            end
           end
+          return hasharray
         end
-        value=hasharray
       end
 
+      private
+
       def initialize
         @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])}
+          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])}
           },
-          :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]},
-          '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
         }
       end
+
       public
 
-      def modifiers;@handlers.keys.map{|i|@handlers[i].keys}.flatten;end
+      def modifiers;@handlers.keys.map{|i|@handlers[i].keys}.flatten.map(&:to_s);end
 
       # add a new :reader or :decoder
       # decoder can be chained, reader is last one on right
       def set_handler(name,type,method)
-        raise "type must be one of #{@handlers.keys}" unless @handlers.keys.include?(type)
         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
       end
 
@@ -67,13 +76,13 @@ module Aspera
         return value if !value.is_a?(String)
         # first determine decoders, in reversed order
         decoders_reversed=[]
-        while (m=value.match(/^@([^:]+):(.*)/)) and @handlers[:decoder].include?(m[1])
-          decoders_reversed.unshift(m[1])
+        while (m=value.match(/^@([^:]+):(.*)/)) && @handlers[:decoder].include?(m[1].to_sym)
+          decoders_reversed.unshift(m[1].to_sym)
           value=m[2]
         end
         # then read value
         @handlers[:reader].each do |reader,method|
-          if m=value.match(/^@#{reader}:(.*)/) then
+          if (m=value.match(/^@#{reader}:(.*)/))
             value=method.call(m[1])
             break
           end