aspera-cli 4.14.0 → 4.16.0

data/lib/aspera/fasp/installation.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
-require 'English'
-require 'singleton'
-require 'aspera/log'
+# cspell:ignore protobuf ckpt
 require 'aspera/environment'
 require 'aspera/data_repository'
+require 'aspera/fasp/products'
+require 'aspera/log'
+require 'aspera/assert'
+require 'aspera/web_server_simple'
+require 'English'
+require 'singleton'
 require 'xmlsimple'
 require 'zlib'
 require 'base64'
@@ -13,24 +17,18 @@ require 'openssl'
 
 module Aspera
   module Fasp
-    # Singleton that tells where to find ascp and other local resources (keys..) , using the "path(symb)" method.
+    # Singleton that tells where to find ascp and other local resources (keys..) , using the "path(:name)" method.
     # It is used by object : AgentDirect to find necessary resources
-    # By default it takes the first Aspera product found specified in product_locations
+    # By default it takes the first Aspera product found
     # but the user can specify ascp location by calling:
     # Installation.instance.use_ascp_from_product(product_name)
     # or
     # Installation.instance.ascp_path=""
     class Installation
       include Singleton
-      # known product names
-      PRODUCT_CONNECT = 'Aspera Connect'
-      PRODUCT_CLI_V1 = 'Aspera CLI'
-      PRODUCT_DRIVE = 'Aspera Drive'
-      PRODUCT_ENTSRV = 'Enterprise Server'
       # protobuf generated files from sdk
       EXT_RUBY_PROTOBUF = '_pb.rb'
       RB_SDK_FOLDER = 'lib'
-      ONE_YEAR_SECONDS = 365 * 24 * 60 * 60
       DEFAULT_ASPERA_CONF = <<~END_OF_CONFIG_FILE
         <?xml version='1.0' encoding='UTF-8'?>
         <CONF version="2">
@@ -42,9 +40,9 @@ module Aspera
         </default>
         </CONF>
       END_OF_CONFIG_FILE
-      DUMMY_CERT_INFO = '/C=US/ST=California/L=Emeryville/O=Aspera Inc./OU=Corporate/CN=Aspera Inc./emailAddress=info@asperasoft.com'
-      private_constant :PRODUCT_CONNECT, :PRODUCT_CLI_V1, :PRODUCT_DRIVE, :PRODUCT_ENTSRV, :EXT_RUBY_PROTOBUF, :RB_SDK_FOLDER,
-        :ONE_YEAR_SECONDS, :DEFAULT_ASPERA_CONF, :DUMMY_CERT_INFO
+      # all ascp files (in SDK)
+      FILES = %i[ascp ascp4 transferd ssh_private_dsa ssh_private_rsa aspera_license aspera_conf fallback_certificate fallback_private_key].freeze
+      private_constant :EXT_RUBY_PROTOBUF, :RB_SDK_FOLDER, :DEFAULT_ASPERA_CONF, :FILES
       # set ascp executable path
       def ascp_path=(v)
         @path_to_ascp = v
@@ -56,7 +54,7 @@ module Aspera
 
       def sdk_ruby_folder
         ruby_pb_folder = File.join(sdk_folder, RB_SDK_FOLDER)
-        FileUtils.mkdir_p(ruby_pb_folder) unless Dir.exist?(ruby_pb_folder)
+        FileUtils.mkdir_p(ruby_pb_folder)
         return ruby_pb_folder
       end
 
@@ -73,61 +71,36 @@ module Aspera
       # @return the path to folder where SDK is installed
       def sdk_folder
         raise 'SDK path was ot initialized' if @sdk_dir.nil?
-        FileUtils.mkdir_p(@sdk_dir) unless Dir.exist?(@sdk_dir)
+        FileUtils.mkdir_p(@sdk_dir)
         @sdk_dir
       end
 
       # find ascp in named product (use value : FIRST_FOUND='FIRST' to just use first one)
-      # or select one from installed_products()
+      # or select one from Products.installed_products()
       def use_ascp_from_product(product_name)
         if product_name.eql?(FIRST_FOUND)
-          pl = installed_products.first
+          pl = Products.installed_products.first
           raise "no FASP installation found\nPlease check manual on how to install FASP." if pl.nil?
         else
-          pl = installed_products.find{|i|i[:name].eql?(product_name)}
+          pl = Products.installed_products.find{|i|i[:name].eql?(product_name)}
           raise "no such product installed: #{product_name}" if pl.nil?
         end
         self.ascp_path = pl[:ascp_path]
         Log.log.debug{"ascp_path=#{@path_to_ascp}"}
       end
 
-      # @return the list of installed products in format of product_locations
-      def installed_products
-        if @found_products.nil?
-          scan_locations = product_locations.clone
-          # add SDK as first search path
-          scan_locations.unshift({
-            expected: 'SDK',
-            app_root: sdk_folder,
-            sub_bin:  ''
-          })
-          # search installed products: with ascp
-          @found_products = scan_locations.select! do |item|
-            # skip if not main folder
-            next false unless Dir.exist?(item[:app_root])
-            Log.log.debug{"Found #{item[:app_root]}"}
-            sub_bin = item[:sub_bin] || BIN_SUBFOLDER
-            item[:ascp_path] = File.join(item[:app_root], sub_bin, ascp_filename)
-            # skip if no ascp
-            next false unless File.exist?(item[:ascp_path])
-            # read info from product info file if present
-            product_info_file = "#{item[:app_root]}/#{PRODUCT_INFO}"
-            if File.exist?(product_info_file)
-              res_s = XmlSimple.xml_in(File.read(product_info_file), {'ForceArray' => false})
-              item[:name] = res_s['name']
-              item[:version] = res_s['version']
-            else
-              item[:name] = item[:expected]
+      # @return [Hash] with key = file name (String), and value = path to file
+      def file_paths
+        return FILES.each_with_object({}) do |v, m|
+          m[v.to_s] =
+            begin
+              path(v)
+            rescue => e
+              e.message
             end
-            true # select this version
-          end
         end
-        return @found_products
       end
 
-      # all ascp files (in SDK)
-      FILES = %i[ascp ascp4 ssh_bypass_dsa_privkey ssh_bypass_rsa_privkey aspera_license aspera_conf fallback_certificate fallback_cert_privkey].freeze
-
       def check_or_create_sdk_file(filename, force: false, &block)
         return Environment.write_file_restricted(File.join(sdk_folder, filename), force: force, mode: 0o644, &block)
       end
@@ -135,6 +108,7 @@ module Aspera
       # get path of one resource file of currently activated product
       # keys and certs are generated locally... (they are well known values, arch. independent)
       def path(k)
+        file_is_optional = false
         case k
         when :ascp, :ascp4
           use_ascp_from_product(FIRST_FOUND) if @path_to_ascp.nil?
@@ -143,69 +117,42 @@ module Aspera
           file = file.gsub('ascp', 'ascp4') if k.eql?(:ascp4)
         when :transferd
           file = transferd_filepath
-        when :ssh_bypass_dsa_privkey
-          file = check_or_create_sdk_file('aspera_bypass_dsa.pem') {get_key('dsa', 1)}
-        when :ssh_bypass_rsa_privkey
-          file = check_or_create_sdk_file('aspera_bypass_rsa.pem') {get_key('rsa', 2)}
+          file_is_optional = true
+        when :ssh_private_dsa, :ssh_private_rsa
+          # assume last 3 letters are type
+          type = k.to_s[-3..-1].to_sym
+          file = check_or_create_sdk_file("aspera_bypass_#{type}.pem") {DataRepository.instance.item(type)}
         when :aspera_license
-          file = check_or_create_sdk_file('aspera-license') do
-            Zlib::Inflate.inflate(DataRepository.instance.data(6))
-          end
+          file = check_or_create_sdk_file('aspera-license') {DataRepository.instance.item(:license)}
         when :aspera_conf
           file = check_or_create_sdk_file('aspera.conf') {DEFAULT_ASPERA_CONF}
-        when :fallback_certificate, :fallback_cert_privkey
+        when :fallback_certificate, :fallback_private_key
           file_key = File.join(sdk_folder, 'aspera_fallback_cert_private_key.pem')
           file_cert = File.join(sdk_folder, 'aspera_fallback_cert.pem')
           if !File.exist?(file_key) || !File.exist?(file_cert)
             require 'openssl'
             # create new self signed certificate for http fallback
-            private_key = OpenSSL::PKey::RSA.new(1024)
             cert = OpenSSL::X509::Certificate.new
-            cert.subject = cert.issuer = OpenSSL::X509::Name.parse(DUMMY_CERT_INFO)
-            cert.not_before = Time.now
-            cert.not_after = Time.now + ONE_YEAR_SECONDS
-            cert.public_key = private_key.public_key
-            cert.serial = 0x0
-            cert.version = 2
-            cert.sign(private_key, OpenSSL::Digest.new('SHA1'))
+            private_key = OpenSSL::PKey::RSA.new(4096)
+            WebServerSimple.fill_self_signed_cert(cert, private_key)
             check_or_create_sdk_file('aspera_fallback_cert_private_key.pem', force: true) {private_key.to_pem}
             check_or_create_sdk_file('aspera_fallback_cert.pem', force: true) {cert.to_pem}
           end
           file = k.eql?(:fallback_certificate) ? file_cert : file_key
-        else
-          raise "INTERNAL ERROR: #{k}"
+        else error_unexpected_value(k)
         end
-        raise "no such file: #{file}" unless File.exist?(file)
+        return nil if file_is_optional && !File.exist?(file)
+        assert(File.exist?(file)){"no such file: #{file}"}
         return file
       end
 
-      # @return the file path of local connect where API's URI can be read
-      def connect_uri
-        connect = get_product_folders(PRODUCT_CONNECT)
-        folder = File.join(connect[:run_root], VAR_RUN_SUBFOLDER)
-        ['', 's'].each do |ext|
-          uri_file = File.join(folder, "http#{ext}.uri")
-          Log.log.debug{"checking connect port file: #{uri_file}"}
-          if File.exist?(uri_file)
-            return File.open(uri_file, &:gets).strip
-          end
-        end
-        raise "no connect uri file found in #{folder}"
-      end
-
-      # @ return path to configuration file of aspera CLI
-      def cli_conf_file
-        connect = get_product_folders(PRODUCT_CLI_V1)
-        return File.join(connect[:app_root], BIN_SUBFOLDER, '.aspera_cli_conf')
-      end
-
       # default bypass key phrase
-      def bypass_pass
-        return format('%08x-%04x-%04x-%04x-%04x%08x', *DataRepository.instance.data(3).unpack('NnnnnN'))
+      def ssh_cert_uuid
+        return DataRepository.instance.item(:uuid)
       end
 
-      def bypass_keys
-        return %i[ssh_bypass_dsa_privkey ssh_bypass_rsa_privkey].map{|i|Installation.instance.path(i)}
+      def aspera_token_ssh_key_paths
+        return %i[ssh_private_dsa ssh_private_rsa].map{|i|Installation.instance.path(i)}
       end
 
       # use in plugin `config`
@@ -226,6 +173,47 @@ module Aspera
         return exe_version
       end
 
+      def ascp_info
+        data = file_paths
+        # read PATHs from ascp directly, and pvcl modules as well
+        Open3.popen3(data['ascp'], '-DDL-') do |_stdin, _stdout, stderr, thread|
+          last_line = ''
+          while (line = stderr.gets)
+            line.chomp!
+            last_line = line
+            case line
+            when /^DBG Path ([^ ]+) (dir|file) +: (.*)$/
+              data[Regexp.last_match(1)] = Regexp.last_match(3)
+            when /^DBG Added module group:"(?<module>[^"]+)" name:"(?<scheme>[^"]+)", version:"(?<version>[^"]+)" interface:"(?<interface>[^"]+)"$/
+              c = Regexp.last_match.named_captures.symbolize_keys
+              data[c[:interface]] ||= {}
+              data[c[:interface]][c[:module]] ||= []
+              data[c[:interface]][c[:module]].push("#{c[:scheme]} v#{c[:version]}")
+            when %r{^DBG License result \(/license/(\S+)\): (.+)$}
+              data[Regexp.last_match(1)] = Regexp.last_match(2)
+            when /^LOG (.+) version ([0-9.]+)$/
+              data['product_name'] = Regexp.last_match(1)
+              data['product_version'] = Regexp.last_match(2)
+            when /^LOG Initializing FASP version ([^,]+),/
+              data['ascp_version'] = Regexp.last_match(1)
+            end
+          end
+          if !thread.value.exitstatus.eql?(1) && !data.key?('root')
+            raise last_line
+          end
+        end
+        # ascp's openssl directory
+        ascp_file = data['ascp']
+        File.binread(ascp_file).scan(/[\x20-\x7E]{4,}/) do |match|
+          if (m = match.match(/OPENSSLDIR.*"(.*)"/))
+            data['openssldir'] = m[1]
+          end
+        end if File.file?(ascp_file)
+        # log is "-" no need to display
+        data.delete('log')
+        return data
+      end
+
       # download aspera SDK or use local file
       # extracts ascp binary for current system architecture
       # @return ascp version (from execution)
@@ -267,123 +255,33 @@ module Aspera
         # ensure license file are generated so that ascp invocation for version works
         path(:aspera_license)
         path(:aspera_conf)
-        ascp_path = File.join(sdk_folder, ascp_filename)
-        raise "No #{ascp_filename} found in SDK archive" unless File.exist?(ascp_path)
+        ascp_file = Products.ascp_filename
+        ascp_path = File.join(sdk_folder, ascp_file)
+        raise "No #{ascp_file} found in SDK archive" unless File.exist?(ascp_path)
         Environment.restrict_file_access(ascp_path, mode: 0o755)
         Environment.restrict_file_access(ascp_path.gsub('ascp', 'ascp4'), mode: 0o755)
-        ascp_version = get_ascp_version(File.join(sdk_folder, ascp_filename))
+        ascp_version = get_ascp_version(ascp_path)
         trd_path = transferd_filepath
         Log.log.warn{"No #{trd_path} in SDK archive"} unless File.exist?(trd_path)
         Environment.restrict_file_access(trd_path, mode: 0o755) if File.exist?(trd_path)
         transferd_version = get_exe_version(trd_path, 'version')
         sdk_version = transferd_version || ascp_version
-        File.write(File.join(sdk_folder, PRODUCT_INFO), "<product><name>IBM Aspera SDK</name><version>#{sdk_version}</version></product>")
+        File.write(File.join(sdk_folder, Products::INFO_META_FILE), "<product><name>IBM Aspera SDK</name><version>#{sdk_version}</version></product>")
         return sdk_version
       end
 
       private
 
-      BIN_SUBFOLDER = 'bin'
-      ETC_SUBFOLDER = 'etc'
-      VAR_RUN_SUBFOLDER = File.join('var', 'run')
-      # product information manifest: XML (part of aspera product)
-      PRODUCT_INFO = 'product-info.mf'
       # policy for product selection
       FIRST_FOUND = 'FIRST'
 
-      private_constant :BIN_SUBFOLDER, :ETC_SUBFOLDER, :VAR_RUN_SUBFOLDER, :PRODUCT_INFO
-
       def initialize
         @path_to_ascp = nil
         @sdk_dir = nil
-        @found_products = nil
-      end
-
-      # @return folder paths for specified applications
-      # @param name Connect or CLI
-      def get_product_folders(name)
-        found = installed_products.select{|i|i[:expected].eql?(name) || i[:name].eql?(name)}
-        raise "Product: #{name} not found, please install." if found.empty?
-        return found.first
-      end
-
-      # filename for ascp with optional extension (Windows)
-      def ascp_filename
-        return 'ascp' + Environment.exe_extension
       end
 
       def transferd_filepath
-        return File.join(sdk_folder, 'asperatransferd' + Environment.exe_extension)
-      end
-
-      # @return product folders depending on OS fields
-      # :expected  M app name is taken from the manifest if present, else defaults to this value
-      # :app_root  M main folder for the application
-      # :log_root  O location of log files (Linux uses syslog)
-      # :run_root  O only for Connect Client, location of http port file
-      # :sub_bin   O subfolder with executables, default : bin
-      def product_locations
-        case Aspera::Environment.os
-        when Aspera::Environment::OS_WINDOWS; return [{
-          expected: PRODUCT_CONNECT,
-          app_root: File.join(ENV['LOCALAPPDATA'], 'Programs', 'Aspera', 'Aspera Connect'),
-          log_root: File.join(ENV['LOCALAPPDATA'], 'Aspera', 'Aspera Connect', 'var', 'log'),
-          run_root: File.join(ENV['LOCALAPPDATA'], 'Aspera', 'Aspera Connect')
-        }, {
-          expected: PRODUCT_CLI_V1,
-          app_root: File.join('C:', 'Program Files', 'Aspera', 'cli'),
-          log_root: File.join('C:', 'Program Files', 'Aspera', 'cli', 'var', 'log')
-        }, {
-          expected: PRODUCT_ENTSRV,
-          app_root: File.join('C:', 'Program Files', 'Aspera', 'Enterprise Server'),
-          log_root: File.join('C:', 'Program Files', 'Aspera', 'Enterprise Server', 'var', 'log')
-        }]
-        when Aspera::Environment::OS_X; return [{
-          expected: PRODUCT_CONNECT,
-          app_root: File.join(Dir.home, 'Applications', 'Aspera Connect.app'),
-          log_root: File.join(Dir.home, 'Library', 'Logs', 'Aspera_Connect'),
-          run_root: File.join(Dir.home, 'Library', 'Application Support', 'Aspera', 'Aspera Connect'),
-          sub_bin:  File.join('Contents', 'Resources')
-        }, {
-          expected: PRODUCT_CONNECT,
-          app_root: File.join('', 'Applications', 'Aspera Connect.app'),
-          log_root: File.join(Dir.home, 'Library', 'Logs', 'Aspera_Connect'),
-          run_root: File.join(Dir.home, 'Library', 'Application Support', 'Aspera', 'Aspera Connect'),
-          sub_bin:  File.join('Contents', 'Resources')
-        }, {
-          expected: PRODUCT_CLI_V1,
-          app_root: File.join(Dir.home, 'Applications', 'Aspera CLI'),
-          log_root: File.join(Dir.home, 'Library', 'Logs', 'Aspera')
-        }, {
-          expected: PRODUCT_ENTSRV,
-          app_root: File.join('', 'Library', 'Aspera'),
-          log_root: File.join(Dir.home, 'Library', 'Logs', 'Aspera')
-        }, {
-          expected: PRODUCT_DRIVE,
-          app_root: File.join('', 'Applications', 'Aspera Drive.app'),
-          log_root: File.join(Dir.home, 'Library', 'Logs', 'Aspera_Drive'),
-          sub_bin:  File.join('Contents', 'Resources')
-        }]
-        else; return [{ # other: Linux and Unix family
-          expected: PRODUCT_CONNECT,
-          app_root: File.join(Dir.home, '.aspera', 'connect'),
-          run_root: File.join(Dir.home, '.aspera', 'connect')
-        }, {
-          expected: PRODUCT_CLI_V1,
-          app_root: File.join(Dir.home, '.aspera', 'cli')
-        }, {
-          expected: PRODUCT_ENTSRV,
-          app_root: File.join('', 'opt', 'aspera')
-        }]
-        end
-      end
-
-      # @return a standard bypass key
-      # @param type rsa or dsa
-      # @param id in repository 1 for dsa, 2 for rsa
-      def get_key(type, id)
-        # generate PEM from DER
-        OpenSSL::PKey.const_get(type.upcase).new(DataRepository.instance.data(id)).to_pem
+        return File.join(sdk_folder, 'asperatransferd' + Environment.exe_extension) # cspell:disable-line
       end
     end # Installation
   end

data/lib/aspera/fasp/management.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+module Aspera
+  module Fasp
+    # executes a local "ascp", connects mgt port, equivalent of "Fasp Manager"
+    class Management
+      # cspell: disable
+      OPERATIONS = %w[
+        NOP
+        START
+        QUERY
+        QUERYRSP
+        STATS
+        STOP
+        ERROR
+        CANCEL
+        DONE
+        RATE
+        FILEERROR
+        SESSION
+        NOTIFICATION
+        INIT
+        VLINK
+        NOTIFICATION
+        PUT
+        WRITE
+        CLOSE
+        SKIP
+        ARGSTOP
+      ]
+
+      PARAMETERS = %w[
+        Type
+        File
+        Size
+        Written
+        Bytescont
+        Rate
+        Loss
+        Query
+        Code
+        Password
+        Progress
+        Remaining
+        Elapsed
+        RexInfo
+        BlockInfo
+        DiskInfo
+        RateInfo
+        MinRate
+        Description
+        Elapsedusec
+        ServiceLevel
+        SessionId
+        User
+        Host
+        Encryption
+        Adaptive
+        Direction
+        Remote
+        Port
+        UserStr
+        CommandId
+        StartByte
+        EndByte
+        Token
+        Cookie
+        QueryResponse
+        Source
+        Destination
+        BWMeasurement
+        BWInfo
+        PMTU
+        TransferBytes
+        FileBytes
+        Operation
+        Delay
+        PreTransferFiles
+        PreTransferDirs
+        PreTransferSpecial
+        PreTransferFailed
+        PartialPreTransferBytes
+        PreTransferBytes
+        Priority
+        Transport
+        VlinkID
+        VlinkOn
+        VlinkCapIn
+        VlinkCapOut
+        ManifestFile
+        ArgScansAttempted
+        ArgScansCompleted
+        PathScansAttempted
+        PathScansFailed
+        PathScansIrregular
+        PathScansExcluded
+        DirScansCompleted
+        FileScansCompleted
+        DirCreatesAttempted
+        DirCreatesFailed
+        DirCreatesPassed
+        TransfersAttempted
+        TransfersFailed
+        TransfersPassed
+        TransfersSkipped
+        FallbackProtocol
+        RetryTimeout
+        PreTransferExcluded
+        XferId
+        XferRetry
+        Tags
+        FaspFileArgIndex
+        ArgTransfersStatus
+        ArgTransfersAttempted
+        ArgTransfersFailed
+        ArgTransfersPassed
+        ArgTransfersSkipped
+        FaspFileID
+        RateCap
+        MinRateCap
+        PolicyCap
+        PriorityCap
+        RateLock
+        MinRateLock
+        PolicyLock
+        FileChecksum
+        ServerHostname
+        ServerNodeId
+        ClientNodeId
+        ServerClusterId
+        ClientClusterId
+        FileChecksumType
+        ServerDocroot
+        ClientDocroot
+        NodeUser
+        ClientUser
+        SourcePrefix
+        RemoteAddress
+        TCPPort
+        Cipher
+        ResumePolicy
+        CreatePolicy
+        ManifestPolicy
+        Precalc
+        OverwritePolicy
+        RTTAutocorrect
+        TimePolicy
+        ManifestPath
+        ManifestInprogress
+        PartialFiles
+        FilesEncrypt
+        FilesDecrypt
+        DatagramSize
+        PrepostCommand
+        XoptFlags
+        VLinkVersion
+        PeerVLinkVersion
+        VLinkLocalEnabled
+        VLinkLocalId
+        VLinkLocalCL
+        VLinkRemoteEnabled
+        VLinkRemoteId
+        VLRemoteCL
+        DSPipelineDepth
+        PeerDSPipelineDepth
+        LocalIP
+        SourceBase
+        ReadBlockSize
+        WriteBlockSize
+        ClusterNumNodes
+        ClusterNodeId
+        MoveRange
+        MoveRangeLow
+        MoveRangeHigh
+        Keepalive
+        TestLogin
+        UseProxy
+        ProxyIP
+        RateControlAlgorithm
+        ClientMacAddress
+        Offset
+        ChunkSize
+        PostTransferValidation
+        OverwritePolicyCap
+        ExtraCreatePolicy]
+      # Management port start message
+      MGT_HEADER = 'FASPMGR 2'
+      # empty line is separator to end event information
+      MGT_FRAME_SEPARATOR = ''
+      # fields description for JSON generation
+      # spellchecker: disable
+      INTEGER_FIELDS = %w[Bytescont FaspFileArgIndex StartByte Rate MinRate Port Priority RateCap MinRateCap TCPPort CreatePolicy TimePolicy
+                          DatagramSize XoptFlags VLinkVersion PeerVLinkVersion DSPipelineDepth PeerDSPipelineDepth ReadBlockSize WriteBlockSize
+                          ClusterNumNodes ClusterNodeId Size Written Loss FileBytes PreTransferBytes TransferBytes PMTU Elapsedusec ArgScansAttempted
+                          ArgScansCompleted PathScansAttempted FileScansCompleted TransfersAttempted TransfersPassed Delay].freeze
+      BOOLEAN_FIELDS = %w[Encryption Remote RateLock MinRateLock PolicyLock FilesEncrypt FilesDecrypt VLinkLocalEnabled VLinkRemoteEnabled
+                          MoveRange Keepalive TestLogin UseProxy Precalc RTTAutocorrect].freeze
+      BOOLEAN_TRUE = 'Yes'
+      # cspell: enable
+
+      class << self
+        # translates mgt port event into (enhanced) typed event
+        def enhanced_event_format(event)
+          return event.keys.each_with_object({}) do |e, h|
+            # capital_to_snake_case
+            new_name = e
+                .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                .gsub(/([a-z\d])(usec)$/, '\1_\2')
+                .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                .downcase
+            value = event[e]
+            value = value.to_i if INTEGER_FIELDS.include?(e)
+            value = value.eql?(BOOLEAN_TRUE) if BOOLEAN_FIELDS.include?(e)
+            h[new_name] = value
+          end
+        end
+      end # class << self
+
+      def initialize
+        # current event being parsed line by line
+        @event_build = nil
+        # last fully built event
+        @last_event = nil
+      end
+      attr_reader :last_event
+
+      def process_line(line)
+        # Log.log.debug{"line=[#{line}]"}
+        case line
+        when MGT_HEADER
+          # begin event
+          @event_build = {}
+        when /^([^:]+): (.*)$/
+          raise 'mgt port: unexpected line: data without header' if @event_build.nil?
+          # event field
+          @event_build[Regexp.last_match(1)] = Regexp.last_match(2)
+        when MGT_FRAME_SEPARATOR
+          raise 'mgt port: unexpected line: end frame without header' if @event_build.nil?
+          @last_event = @event_build
+          @event_build = nil
+          return @last_event
+        else
+          raise "mgt port: unexpected line: [#{line}]"
+        end # case
+        return nil
+      end
+    end
+  end
+end