aspera-cli 4.27.5 → 4.28.0

data/lib/aspera/cli/vault_manager.rb

@@ -33,11 +33,12 @@ module Aspera
 
       # @return [String] value from vault matching <name>.<param>
       def vault_value(name)
-        m = name.split('.')
-        Aspera.assert(m.length.eql?(2), type: BadArgument) { 'vault name shall match <name>.<param>' }
-        info = vault_required.get(label: m[0])
-        value = info[m[1].to_sym]
-        raise "no such entry value: #{m[1]}" if value.nil?
+        # Label may contain dots (e.g. preset name)
+        label, _, param = name.rpartition('.')
+        Aspera.assert(!label.empty? && !param.empty?, type: BadArgument) { 'vault name shall match <name>.<param>' }
+        info = vault_required.get(label: label)
+        value = info[param.to_sym]
+        raise "no such entry value: #{param}" if value.nil?
         return value
       end
 

data/lib/aspera/cli/version.rb

@@ -4,6 +4,6 @@ module Aspera
   module Cli
     # For beta add extension : .beta1
     # For dev version add extension : .pre
-    VERSION = '4.27.5'
+    VERSION = '4.28.0'
   end
 end

data/lib/aspera/cli/web_secret.html.erb

@@ -0,0 +1,61 @@
+<%# Content of the secret page, in layout of Aspera::WebPage %>
+<% if state.eql?(:form) %>
+        <div class="icon-circle">
+            <svg xmlns="http://www.w3.org/2000/svg" width="28" height="28" viewBox="0 0 32 32" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round">
+                <rect x="6" y="13" width="20" height="15" rx="3"/>
+                <path d="M10 13V9a6 6 0 0 1 12 0v4"/>
+                <circle cx="16" cy="20.5" r="2" fill="currentColor"/>
+            </svg>
+        </div>
+
+        <h1>Secret request</h1>
+<% if requester %>
+        <p><%= h name %> needs the secret <span class="client"><%= h prompt %></span> to execute a command requested by the <%= h requester %>.</p>
+        <p>The secret is sent to <%= h name %> only: the <%= h requester %> does not see it.</p>
+<% else %>
+        <p><%= h name %> needs the secret <span class="client"><%= h prompt %></span> to execute your command.</p>
+<% end %>
+<% if error %>
+        <p class="error"><%= h error %></p>
+<% end %>
+
+        <form method="POST" action="<%= h action_url %>">
+<% if access_code_required %>
+            <label class="secret">Server access code
+                <input type="password" name="access_code" autocomplete="off" required autofocus>
+            </label>
+<% end %>
+            <label class="secret">Secret: <%= h prompt %>
+                <input type="password" name="secret" autocomplete="off" required<%= ' autofocus' unless access_code_required %>>
+            </label>
+            <div class="actions">
+                <button class="allow" type="submit" name="decision" value="submit">Submit</button>
+                <button class="deny"  type="submit" name="decision" value="cancel" formnovalidate>Cancel</button>
+            </div>
+        </form>
+<% elsif state.eql?(:received) %>
+        <div class="icon-circle ok">
+            <svg xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 32 32" fill="none" stroke="currentColor" stroke-width="3" stroke-linecap="round" stroke-linejoin="round">
+                <polyline points="6 16 13 23 26 9"/>
+            </svg>
+        </div>
+
+        <h1>Secret received</h1>
+        <p>You can close this window and return to your <%= h(requester || 'terminal') %>.</p>
+<% else %>
+        <div class="icon-circle ko">
+            <svg xmlns="http://www.w3.org/2000/svg" width="28" height="28" viewBox="0 0 32 32" fill="none" stroke="currentColor" stroke-width="3" stroke-linecap="round" stroke-linejoin="round">
+                <line x1="9" y1="9" x2="23" y2="23"/>
+                <line x1="23" y1="9" x2="9" y2="23"/>
+            </svg>
+        </div>
+
+<% if state.eql?(:cancelled) %>
+        <h1>Secret request cancelled</h1>
+        <p>The command will fail. You can close this window and return to your <%= h(requester || 'terminal') %>.</p>
+<% else %>
+        <h1>Unknown secret request</h1>
+        <p>This request is unknown, expired, or already answered.</p>
+<% end %>
+<% end %>
+

data/lib/aspera/cli/web_secret.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+# cspell:ignore urlsafe
+
+require 'aspera/log'
+require 'aspera/assert'
+require 'aspera/environment'
+require 'aspera/web_page'
+require 'aspera/servlet_helpers'
+require 'aspera/cli/error'
+require 'aspera/cli/info'
+require 'openssl'
+require 'securerandom'
+
+module Aspera
+  module Cli
+    # Secrets entered by the user on a web page, instead of the terminal.
+    # Used by extended value `@secret:` when option `ui` is `graphical`, and in MCP server mode (see Mcp::Secrets).
+    #
+    # Requests are kept in memory, identified by a random value in the URL of the page, and expire after TTL seconds.
+    # Pages are served by a local web server, started on first request, or by the web server of the caller (see #handle).
+    class WebSecret
+      # Lifetime of a request in seconds: the user shall enter the secret within this time
+      TTL = 600
+      # Path of the page, followed by the request identifier
+      PATH_PREFIX = '/secret/'
+      # Interval in seconds between calls to the block while waiting for the user
+      WAIT_SLICE = 10
+      # Address of the local web server
+      LOCAL_ADDRESS = '127.0.0.1'
+      # Maximum time in seconds to wait for the local web server to send the last page on shutdown
+      SHUTDOWN_TIMEOUT = 5
+      # ERB template of the page
+      HTML_TEMPLATE_PATH = File.join(__dir__, 'web_secret.html.erb')
+      # A request for a secret, status is one of: :pending, :received, :cancelled
+      Request = Struct.new(:prompt, :status, :value, :expires_at, keyword_init: true)
+      private_constant :WAIT_SLICE, :LOCAL_ADDRESS, :SHUTDOWN_TIMEOUT, :HTML_TEMPLATE_PATH, :Request
+
+      class << self
+        # Ask for a secret on a web page, opened in the browser
+        # @param prompt [String] Name of the secret
+        # @return [String] The secret
+        def ask(prompt)
+          web_secret = new
+          id = web_secret.create(prompt)
+          Environment.instance.open_uri(web_secret.url(id))
+          web_secret.wait_value(id)
+        ensure
+          web_secret&.shutdown
+        end
+      end
+
+      # @param base_url    [String, nil] URL of the web server serving the pages (see #handle), `nil` to start a local web server on first request
+      # @param access_code [String, nil] If set, the user must also enter it on the page
+      # @param name        [String]      Name of the application needing the secret, shown on the page
+      # @param requester   [String, nil] Who requested the command, shown on the page, e.g. `AI assistant`, `nil` for the user on terminal
+      def initialize(base_url: nil, access_code: nil, name: Info::CMD_NAME, requester: nil)
+        Aspera.assert(access_code.nil? || !access_code.to_s.empty?) { 'access_code must not be empty' }
+        @base_url     = base_url
+        @access_code  = access_code&.to_s
+        @name         = name
+        @requester    = requester
+        @mutex        = Mutex.new
+        @cond         = ConditionVariable.new
+        # id => Request
+        @requests     = {}
+        @local_server = nil
+        @local_thread = nil
+      end
+
+      # @param prompt [String] Name of the secret, shown to the user
+      # @return [String] Identifier of the new request
+      def create(prompt)
+        id = SecureRandom.urlsafe_base64(24)
+        @mutex.synchronize do
+          purge_expired
+          @requests[id] = Request.new(prompt: prompt, status: :pending, expires_at: Time.now + TTL)
+        end
+        id
+      end
+
+      # @param id [String] Identifier of the request
+      # @return [String] URL of the page where the user enters the secret
+      def url(id)
+        "#{base_url}#{PATH_PREFIX}#{id}"
+      end
+
+      # @param id [String] Identifier of the request
+      # @return [String, nil] Prompt of the request, `nil` if unknown or expired
+      def prompt(id)
+        @mutex.synchronize { live_request(id)&.prompt }
+      end
+
+      # Wait until the user enters the secret, or cancels, on the page
+      # @param id [String] Identifier of the request
+      # @yield [elapsed] Called periodically while waiting, with elapsed seconds
+      # @return [String] The secret
+      # @raise [Cli::Error] if the request is unknown, expired, or cancelled by the user
+      def wait_value(id)
+        start = Time.now
+        loop do
+          @mutex.synchronize do
+            request = live_request(id)
+            raise Error, 'Secret request expired: execute the command again' if request.nil?
+            raise Error, 'Secret entry cancelled by user' if request.status.eql?(:cancelled)
+            return request.value if request.status.eql?(:received)
+            @cond.wait(@mutex, (request.expires_at - Time.now).clamp(0, WAIT_SLICE))
+          end
+          yield(Time.now - start) if block_given?
+        end
+      end
+
+      # Forget requests, and their secrets
+      # @param ids [Array<String>] Identifiers of requests
+      def delete(ids)
+        @mutex.synchronize { ids.each { |id| @requests.delete(id) } }
+      end
+
+      # Stop the local web server, if started, after it sends the last page to the browser
+      def shutdown
+        return if @local_server.nil?
+        @local_server.shutdown
+        @local_thread.join(SHUTDOWN_TIMEOUT)
+      end
+
+      # Serve the page: GET shows the form, POST receives the secret or the cancellation
+      # @param req [WEBrick::HTTPRequest]
+      # @param res [WEBrick::HTTPResponse]
+      def handle(req, res)
+        require 'webrick'
+        id = req.path.delete_prefix(PATH_PREFIX)
+        status, page = @mutex.synchronize do
+          request = live_request(id)
+          if request.nil? || !request.status.eql?(:pending)
+            [404, {state: :unknown}]
+          elsif req.request_method.eql?('GET')
+            [200, {state: :form, prompt: request.prompt}]
+          elsif req.request_method.eql?('POST')
+            answer(request, WEBrick::HTTPUtils.parse_query(req.body.to_s))
+          else
+            [405, {state: :unknown}]
+          end
+        end
+        res.status = status
+        WebPage.secure_headers(res)
+        # Variables of the template, state is one of: :form, :received, :cancelled, :unknown
+        res.body = WebPage.render(
+          HTML_TEMPLATE_PATH,
+          title:                'Secret request',
+          name:                 @name,
+          requester:            @requester,
+          action_url:           "#{PATH_PREFIX}#{id}",
+          access_code_required: !@access_code.nil?,
+          prompt:               nil,
+          error:                nil,
+          **page
+        )
+      end
+
+      private
+
+      # Record the answer of the user, called with the mutex locked
+      # @param request [Request] The pending request
+      # @param params  [Hash]    Fields of the form
+      # @return [Array] HTTP status and attributes of the page
+      def answer(request, params)
+        if params['decision'].eql?('cancel')
+          request.status = :cancelled
+        elsif @access_code && !OpenSSL.secure_compare(params['access_code'].to_s, @access_code)
+          Log.log.warn('Secret page: wrong access code')
+          return [401, {state: :form, prompt: request.prompt, error: 'Invalid access code'}]
+        else
+          # Form data is binary, the page is UTF-8
+          request.value = params['secret'].to_s.dup.force_encoding(Encoding::UTF_8)
+          request.status = :received
+        end
+        @cond.broadcast
+        [200, {state: request.status}]
+      end
+
+      # Called with the mutex locked
+      # @return [Request, nil] The request, `nil` if unknown or expired
+      def live_request(id)
+        request = @requests[id]
+        request unless request.nil? || request.expires_at < Time.now
+      end
+
+      def purge_expired
+        now = Time.now
+        @requests.delete_if { |_, request| request.expires_at < now }
+      end
+
+      # @return [String] URL of the server, for the browser
+      def base_url
+        @mutex.synchronize { @base_url ||= start_local_server }
+      end
+
+      # Start a local web server for the pages
+      # @return [String] URL of the local server
+      def start_local_server
+        require 'aspera/web_server_simple'
+        servlet = Class.new(WEBrick::HTTPServlet::AbstractServlet) do
+          include ServletHelpers
+
+          # Refuse requests of other web pages, the WebSecret instance is the option of the servlet
+          def service(req, res)
+            check_request(req)
+            @options.first.handle(req, res)
+          end
+        end
+        # Port 0: any free port
+        @local_server = WebServerSimple.new(URI::HTTP.build(host: LOCAL_ADDRESS, port: 0))
+        @local_server.mount(PATH_PREFIX, servlet, self)
+        # In a thread: signals are not trapped by the server
+        @local_thread = Thread.new { @local_server.start }
+        @local_server.uri.to_s
+      end
+    end
+  end
+end

data/lib/aspera/cli/wizard.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
-require 'aspera/oauth/jwt'
+require 'aspera/oauth/client/jwt'
 require 'aspera/assert'
+require 'aspera/environment'
+require 'aspera/id_generator'
 require 'aspera/cli/option_declarator'
 require 'aspera/cli/plugins/factory'
 require 'aspera/rainbow'
@@ -13,7 +15,7 @@ module Aspera
     class Wizard
       extend OptionDeclarator
 
-      WIZARD_RESULT_KEYS = %i[preset_value test_args].freeze
+      WIZARD_RESULT_KEYS = %i[preset_ids preset_value test_args].freeze
       DEFAULT_PRIV_KEY_FILENAME = 'my_private_key.pem' # pragma: allowlist secret
       private_constant :WIZARD_RESULT_KEYS, :DEFAULT_PRIV_KEY_FILENAME
 
@@ -84,10 +86,18 @@ module Aspera
         return found_apps
       end
 
+      # Display the path to a page of the web UI
+      # @param steps [Array<String>] Menus and pages, from the top (e.g. `Environment.char('👤')` for the user menu)
+      # @return [nil]
+      def display_navigation(*steps)
+        formatter.display_status("Navigate to: #{steps.join(" #{Environment.char('→')} ")}")
+        nil
+      end
+
       # To be called in public wizard method to get private key
       # @param user [String] User's email
       # @param url  [String] Instance URL
-      # @param page [String] URL of page to enter pub key
+      # @param page [Array<String>] Navigation steps to the page to enter the public key (see `display_navigation`)
       # @return [String] Private key path (can contain ~ for home)
       def ask_private_key(user:, url:, page:)
         # Lets see if path to priv key is provided
@@ -111,7 +121,7 @@ module Aspera
         pub_key_pem = OpenSSL::PKey::RSA.new(private_key_pem).public_key.to_s
         options.set_option(:private_key, private_key_pem)
         formatter.display_status("Please Log in as user #{user.red} at: #{url.red}")
-        formatter.display_status("Navigate to: #{page}")
+        display_navigation(*page)
         formatter.display_status("Check or update the value to (#{'including BEGIN/END lines'.red}):".blink)
         formatter.display_status(pub_key_pem, hide_secrets: false)
         formatter.display_status('Once updated or validated, press [Enter].')
@@ -146,14 +156,14 @@ module Aspera
         wizard_result = plugin_instance.wizard(self, wiz_url)
         Log.log.debug { "wizard result: #{wizard_result}" }
         Aspera.assert(WIZARD_RESULT_KEYS.eql?(wizard_result.keys.sort)) { "missing or extra keys in wizard result: #{wizard_result.keys}" }
+        Aspera.assert_array_all(wizard_result[:preset_ids], String) { 'preset_ids' }
         # Get preset name from user or default
         if wiz_preset_name.empty?
-          elements = [
+          wiz_preset_name = IdGenerator.from_list(
             identification[:product],
-            URI.parse(wiz_url).host
-          ]
-          elements.push(options.get_option(:username, mandatory: true)) unless wizard_result[:preset_value].key?(:link) rescue nil
-          wiz_preset_name = elements.join('_').strip.downcase.gsub(/[^a-z0-9]/, '_').squeeze('_')
+            wiz_url,
+            *wizard_result[:preset_ids]
+          )
         end
         # Write configuration file
         formatter.display_status("Preparing preset: #{wiz_preset_name}")

data/lib/aspera/command_line_builder.rb

@@ -31,6 +31,7 @@ module Aspera
       'x-agents',       # [Array]        Supported agents (for doc only), if not specified: all
       'x-ts-name',      # [Boolean,String] (async) true if same name in transfer spec, else real name in transfer spec, else ignored
       'x-ts-convert',   # [String]       (async) Name of methods to convert value from transfer spec to `conf` API.
+      'x-unit',         # [String]       (async) Time unit of the integer value in `conf` (e.g. `ms`), command line option is a DURATION
       'x-deprecation'   # [String]       Deprecation message for doc
     ].freeze
 
@@ -52,6 +53,30 @@ module Aspera
         !properties.key?('x-agents') || properties['x-agents'].include?(agent.to_s)
       end
 
+      # Documentation of the command line option of a property: `annotate` of `Schema::Documentation`
+      # @param node      [Hash]               Schema of the property
+      # @param formatter [FormatterInterface] Formatter of the documentation
+      # @return [Array<String>] Lines added to the description, empty if no option
+      def doc_lines(node, formatter)
+        envvar_prefix = ''
+        cli_option =
+          if node.key?('x-cli-envvar')
+            envvar_prefix = 'env:'
+            node['x-cli-envvar']
+          elsif node['x-cli-switch']
+            false_part = node.key?('x-cli-false') ? " / #{node['x-cli-false']}" : ''
+            "#{node['x-cli-option']}#{false_part}"
+          elsif node['x-cli-option']
+            arg_type = node.key?('enum') ? '{enum}' : "{#{[node['type']].flatten.join('|')}}"
+            conversion_tag = node.key?('x-cli-convert') ? 'conversion' : nil
+            sep = node['x-cli-option'].start_with?('--') ? '=' : ' '
+            "#{node['x-cli-option']}#{sep}#{"(#{conversion_tag})" if conversion_tag}#{arg_type}"
+          end
+        return [] unless cli_option
+        short = node.key?('x-cli-short') ? "(#{node['x-cli-short']})" : nil
+        ["(#{'special:' if node['x-cli-special']}#{envvar_prefix}#{formatter.markdown_text("`#{cli_option}`")})#{short}"]
+      end
+
       private
 
       # `ascp`: mandatory type
@@ -72,6 +97,7 @@ module Aspera
           Aspera.assert(node['type'].eql?('boolean')) { "switch must be bool: #{name}" } if node['x-cli-switch'] && !node['x-cli-special']
           Aspera.assert(node['x-cli-switch']) { "boolean direct option must have x-cli-switch: #{name}" } if node['type'].eql?('boolean') && node.key?('x-cli-option') && supported_by_agent(:direct, node) && !node['x-cli-special']
           node['x-cli-option'] = "--#{name.to_s.tr('_', '-')}" if node['x-cli-option'].eql?(true) || (node['x-cli-switch'].eql?(true) && !node.key?('x-cli-option'))
+          Aspera.assert(supported_by_agent(:direct, node)) { "#{name}: x-cli-option requires agent direct (or nil)" } if node['x-cli-option']
           Aspera.assert(DIRECT_PROPERTIES.any? { |i| node.key?(i) }, name, type: :warn) if ascp && supported_by_agent(:direct, node)
           node.freeze
         end

data/lib/aspera/data_repository.rb

@@ -4,6 +4,7 @@ require 'aspera/assert'
 require 'singleton'
 require 'openssl'
 require 'zlib'
+require 'base64'
 
 module Aspera
   # a simple binary data repository
@@ -14,39 +15,52 @@ module Aspera
   class DataRepository
     include Singleton
 
-    # in same order as elements in folder
-    ELEMENTS = %i[dsa rsa uuid aspera.global-cli-client aspera.drive license]
-    START_INDEX = 1
+    # name of data item => name of its file in data folder
+    FILES = {
+      dsa:                        '1',
+      rsa:                        '2',
+      uuid:                       '3',
+      'aspera.global-cli-client': '4',
+      'aspera.drive':             '5',
+      license:                    '6'
+    }.freeze
+    # names of data items
+    ELEMENTS = FILES.keys.freeze
     DATA_FOLDER_NAME = 'data'
 
-    # decode data as expected as string
-    # @param name [Symbol] name of the data item
-    # @return [String] decoded data
+    # Get a data item, decoded to its usable form
+    # @param name [Symbol] name of the data item, one of ELEMENTS
+    # @return [String] PEM private key (dsa, rsa), UUID (uuid), base64url secret (client apps), or text (license)
     def item(name)
-      index = ELEMENTS.index(name)
-      Aspera.assert(index, type: ParameterError) { "Unknown data item #{name} (#{name.class})" }
-      raw_data = data(START_INDEX + index)
-      case name
-      when :dsa, :rsa
-        # generate PEM from DER
-        return OpenSSL::PKey.const_get(name.to_s.upcase).new(raw_data).to_pem
-      when :license
-        return Zlib::Inflate.inflate(raw_data)
-      when :uuid
-        return format('%08x-%04x-%04x-%04x-%04x%08x', *raw_data.unpack('NnnnnN'))
-      when :'aspera.global-cli-client', :'aspera.drive'
-        return Base64.urlsafe_encode64(raw_data)
-      else Aspera.error_unexpected_value(name)
-      end
+      Aspera.assert_values(name, ELEMENTS, type: ParameterError) { 'data item' }
+      raw_data = data(name)
+      value =
+        case name
+        when :dsa, :rsa
+          # generate PEM from DER
+          # Class of key, not `OpenSSL::PKey.read`: on JRuby (jruby-openssl 0.16), it fails on these keys (DER, traditional format)
+          {dsa: OpenSSL::PKey::DSA, rsa: OpenSSL::PKey::RSA}[name].new(raw_data).to_pem
+        when :license
+          Zlib::Inflate.inflate(raw_data)
+        when :uuid
+          format('%08x-%04x-%04x-%04x-%04x%08x', *raw_data.unpack('NnnnnN'))
+        when :'aspera.global-cli-client', :'aspera.drive'
+          Base64.urlsafe_encode64(raw_data)
+        else Aspera.error_unexpected_value(name)
+        end
+      # all items are text
+      return value.force_encoding(Encoding::UTF_8)
     end
 
     private
 
-    private_constant :START_INDEX, :DATA_FOLDER_NAME
+    private_constant :FILES, :DATA_FOLDER_NAME
 
     # get binary value from data repository
-    def data(id)
-      File.read(File.join(__dir__, DATA_FOLDER_NAME, id.to_s), mode: 'rb')
+    # @param name [Symbol] name of the data item
+    # @return [String] raw binary data
+    def data(name)
+      File.binread(File.join(__dir__, DATA_FOLDER_NAME, FILES[name]))
     end
   end
 end

data/lib/aspera/duration.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'aspera/assert'
+require 'strscan'
+
+module Aspera
+  # Duration in the format of Aspera Sync (`async` DURATION)
+  module Duration
+    # Microseconds per unit
+    UNIT_US = {'w' => 604_800_000_000, 'd' => 86_400_000_000, 'h' => 3_600_000_000, 'm' => 60_000_000, 's' => 1_000_000, 'ms' => 1_000, 'us' => 1}.freeze
+    private_constant :UNIT_US
+
+    class << self
+      # Convert a duration to an integer in the given time unit
+      # @param value [String] `DDd HH:MM:SS.mmm` or `NNw NNd NNh NNm NNs NNms NNus`, leading fields and spaces may be omitted, a plain number is seconds
+      # @param unit  [String] Time unit of result, e.g. `ms`
+      # @return [Integer] Duration in `unit`, rounded down
+      def to_unit(value, unit)
+        Aspera.assert_values(unit, UNIT_US.keys) { 'duration unit' }
+        value = value.to_s.delete(' ')
+        if (m = value.match(/\A(?:(\d+)d)?(?:(?:(\d+):)?(\d+):)?(\d+)(?:\.(\d{1,3}))?\z/))
+          days, hours, minutes, seconds, millis = m.captures
+          hours = (days.to_i * 24) + hours.to_i
+          minutes = (hours * 60) + minutes.to_i
+          seconds = (minutes * 60) + seconds.to_i
+          microseconds = (seconds * UNIT_US['s']) + (millis.to_s.ljust(3, '0').to_i * UNIT_US['ms'])
+        else
+          # anchored sequential matching (linear time, no backtracking over start positions)
+          scanner = StringScanner.new(value)
+          units = []
+          until scanner.eos?
+            Aspera.assert(scanner.scan(/(\d+)(ms|us|[wdhms])/), type: ParameterError) { "Invalid duration: #{value}" }
+            units.push([scanner[1], scanner[2]])
+          end
+          Aspera.assert(!units.empty?, type: ParameterError) { "Invalid duration: #{value}" }
+          microseconds = units.sum { |number, number_unit| number.to_i * UNIT_US[number_unit] }
+        end
+        microseconds / UNIT_US[unit]
+      end
+    end
+  end
+end