asterism 0.7.0 → 0.8.0

data/lib/asterism/cruby/zenoh.rb

@@ -69,8 +69,13 @@ module Asterism
 
     # Opens a session (the arguments of Session.open) and wraps it in a
     # Connection. With a block: yields it, closes it when the block ends
-    # (also on an exception) and returns the block's value.
-    def self.open(locator = nil, interval: Runner::DEFAULT_INTERVAL, **opts)
+    # (also on an exception) and returns the block's value. credentials: a
+    # .tar from an Asterism console (Asterism::Credentials): mutual TLS with
+    # its certificates, to its router unless a locator is given.
+    def self.open(locator = nil, interval: Runner::DEFAULT_INTERVAL, credentials: nil, **opts)
+      if credentials
+        locator, opts[:config], = ::Asterism::Credentials.merge(credentials, locator, opts[:config])
+      end
       conn = Connection.new(Session.open(locator, **opts), interval: interval)
       return conn unless block_given?
       begin
@@ -358,6 +363,12 @@ module Asterism
         @session.closed?
       end
 
+      # True while the router is away and zenoh-c opens the connection
+      # again (a client session; what was declared comes back with it).
+      def reconnecting?
+        @session.reconnecting?
+      end
+
       def zid
         @session.zid
       end

data/lib/asterism/version.rb

@@ -3,5 +3,5 @@ module Asterism
   # is in asterism.gemspec (asterism-zenoh ~> 0.4.0 for 0.5.0 to 0.7.0:
   # the bindings did not change; see CHANGELOG.md). 0.7.0 speaks wire
   # protocol 1 only (Asterism::PROTOCOL, docs/protocol.md).
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 end

data/lib/asterism.rb

@@ -12,12 +12,12 @@ require "asterism/zenoh"
 require_relative "asterism/version"
 
 # The same order as an mrbgem's mrblib (alphabetical).
-%w[asterism cdr future profile proxy ros].each do |f|
+%w[asterism cdr credentials future profile proxy ros status].each do |f|
   require_relative "../mrblib/#{f}"
 end
 require_relative "asterism/cruby"
 # The CRuby API on top (blocks, a receiving thread, Enumerators,
 # pattern matching): CRuby only, see README "The CRuby API".
-%w[runner zenoh objects ros].each do |f|
+%w[runner credentials zenoh objects ros].each do |f|
   require_relative "asterism/cruby/#{f}"
 end

data/mrblib/asterism.rb

@@ -13,10 +13,12 @@
 #                     reply {"value" => v} or
 #                     {"error" => {"kind" => k, "class" => c, "message" => m}}
 #   asterism/<node>/<app>/<object>/meta
-#                     get: reply {"methods" => [{"name" => n, "arity" => a}, ...]}
+#                     get: reply {"methods" => [{"name" => n, "arity" => a,
+#                     "args" => [...], "doc" => "..."}, ...], "doc" => "..."}
 #   asterism/<node>/<app>             liveliness: the application is up
 #   asterism/<node>/<app>/<object>    liveliness: the object is exposed
 #   asterism/<node>/@profile          get: reply the node's profile (profile.rb)
+#   asterism/<node>/<app>/@status     get: reply the application's status (status.rb)
 #
 # Everything is polled: nothing runs behind the application's back. A call
 # that waits for its answer keeps polling meanwhile and answers the calls
@@ -240,16 +242,23 @@ module Asterism
   # Opens the connection. locator, mode: and listen: go to
   # Asterism::Zenoh::Session.open (client of a router by default; mode: :peer
   # with or without listen: for no router), and so do config: (a Hash of
-  # "key/path" => value or a JSON5 String, e.g. TLS certificates) and
-  # connect_timeout: (seconds) when they are given (CRuby's asterism-zenoh
-  # only; the boards raise ArgumentError). node: is this machine's ID and
-  # app: this application's name. check_timeout: how long to look for
-  # another copy of the same <node>/<app> (seconds, CHECK_TIMEOUT). Raises
-  # Disconnected when it cannot connect, and Error when the same
-  # <node>/<app> is already on the network.
-  def self.connect(locator, node:, app:, mode: nil, listen: nil, config: nil, connect_timeout: nil,
-                   check_timeout: nil)
+  # "key/path" => value or a JSON5 String, e.g. TLS certificates; the boards
+  # take the TLS keys only) and connect_timeout: (seconds; CRuby's
+  # asterism-zenoh only, the boards raise ArgumentError) when they are given.
+  # credentials: a .tar from an Asterism console (Asterism::Credentials, a
+  # path or a loaded one): its certificates go to zenoh (mutual TLS), and
+  # locator and node: default to its router and name. node: is this
+  # machine's ID and app: this application's name. check_timeout: how long
+  # to look for another copy of the same <node>/<app> (seconds,
+  # CHECK_TIMEOUT). Raises Disconnected when it cannot connect, and Error
+  # when the same <node>/<app> is already on the network.
+  def self.connect(locator = nil, node: nil, app:, mode: nil, listen: nil, config: nil, connect_timeout: nil,
+                   check_timeout: nil, credentials: nil)
     raise Error, "already connected (Asterism.close first)" if connected?
+    if credentials
+      locator, config, creds = Credentials.merge(credentials, locator, config)
+      node ||= creds.name
+    end
     release
     node = check_name("node", node)
     app = check_name("app", app)
@@ -279,7 +288,8 @@ module Asterism
     @session = s
     @node = node
     @app = app
-    @objects = {}  # name => [object, {method name => arity}, token, caller keyword or nil]
+    @objects = {}  # name => [object, {method name => arity}, token, caller keyword or nil,
+                   #          {method name => meta fields}, the object's doc or nil]
     @alive = {}    # "node/app/object" => node (from liveliness)
     @apps = {}     # "node/app" => node (from liveliness)
     @proxies = {}
@@ -287,9 +297,13 @@ module Asterism
     @lost = nil
     @known = []    # the other nodes told to on_join so far
     @known_set = {} # the same, as node => true
+    @known_apps = {} # "node/app" => true: the other applications told to on_app_join
     @node_list = [node] # what nodes returns (this node first), rebuilt on a change
     @nodes_changed = false # liveliness changed since tell_nodes last compared
+    @was_reconnecting = false
+    @status_put = nil
     tell_profile   # for those who follow the profiles (the reply is the queryable's)
+    tell_status(true) # a status set before connecting (status.rb)
     self
   end
 
@@ -320,6 +334,20 @@ module Asterism
     true
   end
 
+  # True while the connection is lost and the Zenoh binding opens it again
+  # by itself (a client of a router: zenoh-pico built with reconnection on
+  # the boards, zenoh-c on CRuby). connected? stays true meanwhile, and once
+  # the router is back everything declared before is there again: the
+  # application token, the exposed objects, the liveliness watch, and what
+  # the application declared on Asterism.session. Meanwhile the other nodes
+  # leave (on_leave) and join again after it, calls raise Disconnected or
+  # time out, and puts reach nobody.
+  def self.reconnecting?
+    s = @session
+    return false if s.nil?
+    s.respond_to?(:reconnecting?) ? s.reconnecting? : false
+  end
+
   def self.node_id
     @node
   end
@@ -338,8 +366,11 @@ module Asterism
   def self.close
     release
     @known = nil
+    @known_apps = nil
     @on_join = nil
     @on_leave = nil
+    @on_app_join = nil
+    @on_app_leave = nil
     nil
   end
 
@@ -365,6 +396,8 @@ module Asterism
     @queryable = nil
     @watch = nil
     @profile_queryable = nil
+    @status_queryable = nil
+    @status_put = nil
   end
 
   # The Zenoh session of the connection (an Asterism::Zenoh::Session), for
@@ -423,21 +456,39 @@ module Asterism
 
   # Makes obj callable from other machines as <node>/<app>/<name>. Only the
   # listed methods can be called. methods: is an Array of names, or a Hash
-  # name => number of arguments (checked before calling; -1 for any).
+  # name => number of arguments (checked before calling; -1 for any), or
+  # name => {args: [names], doc: "text"} (docs/protocol.md 5): the
+  # arguments' names (their number is the number checked, unless arity:
+  # says otherwise) and what the method does, both told in the meta for
+  # the readers that show them (asterism mcp, the command line). doc: a
+  # text about the object itself, also in the meta.
   # caller: a keyword name (caller: :from): each call passes the calling
   # node's ID (Asterism.current_call.from) to the method as that keyword,
   # and a call that brings the keyword itself is refused (an "arguments"
   # error), so the value is always the one Asterism took from the call.
-  def self.expose(name, obj, methods:, caller: nil)
+  def self.expose(name, obj, methods:, caller: nil, doc: nil)
     s = session!
     name = check_name("object", name)
     table = {}
+    info = {}
     if methods.is_a?(Hash)
-      methods.each { |m, n| table[m.to_s] = n.to_i }
+      methods.each do |m, n|
+        if n.is_a?(Hash)
+          d = method_doc(m, n)
+          table[m.to_s] = d[0]
+          info[m.to_s] = d[1]
+        else
+          table[m.to_s] = n.to_i
+        end
+      end
     else
       methods.each { |m| table[m.to_s] = -1 }
     end
     raise ArgumentError, "no method to expose" if table.empty?
+    unless doc.nil?
+      raise ArgumentError, "doc: expects a String, got #{doc.class}" unless doc.is_a?(String)
+      raise ArgumentError, "doc: at most #{DOC_MAX} bytes" if doc.bytesize > DOC_MAX
+    end
     table.each_key do |m|
       raise ArgumentError, "#{obj.class} has no public method #{m}" unless obj.respond_to?(m)
     end
@@ -451,12 +502,60 @@ module Asterism
     end
     unexpose(name)
     token = s.liveliness("#{ROOT}/#{@node}/#{@app}/#{name}")
-    @objects[name] = [obj, table, token, kw]
+    @objects[name] = [obj, table, token, kw, info, doc]
     "#{@node}/#{@app}/#{name}"
   rescue Asterism::Zenoh::Error => e
     raise Disconnected, e.message
   end
 
+  # The longest doc text (bytes) and the most argument names a method may
+  # tell in its meta (docs/protocol.md 5).
+  DOC_MAX = 2048
+  ARGS_MAX = 16
+
+  # A method's {args:, doc:, arity:} at expose: [the number of arguments
+  # checked, its meta fields {"args", "doc"}].
+  # @api private
+  def self.method_doc(m, h)
+    args = nil
+    doc = nil
+    arity = nil
+    h.each do |k, v|
+      ks = k.to_s
+      if ks == "args" then args = v
+      elsif ks == "doc" then doc = v
+      elsif ks == "arity" then arity = v
+      else raise ArgumentError, "#{m}: unknown key #{ks} (args:, doc:, arity:)"
+      end
+    end
+    out = {}
+    unless args.nil?
+      raise ArgumentError, "#{m}: args: expects an Array of names" unless args.is_a?(Array)
+      raise ArgumentError, "#{m}: args: at most #{ARGS_MAX} names" if args.size > ARGS_MAX
+      names = []
+      args.each do |a|
+        raise ArgumentError, "#{m}: args: expects names, got #{a.inspect}" unless a.is_a?(String) || a.is_a?(Symbol)
+        a = a.to_s
+        raise ArgumentError, "#{m}: args: an empty name" if a.empty? || a.bytesize > 64
+        names << a
+      end
+      out["args"] = names
+    end
+    unless doc.nil?
+      raise ArgumentError, "#{m}: doc: expects a String" unless doc.is_a?(String)
+      raise ArgumentError, "#{m}: doc: at most #{DOC_MAX} bytes" if doc.bytesize > DOC_MAX
+      out["doc"] = doc
+    end
+    n = if !arity.nil? then arity.to_i
+        elsif !args.nil? then args.size
+        else -1
+        end
+    if n >= 0 && !args.nil? && args.size != n
+      raise ArgumentError, "#{m}: #{args.size} names in args: for #{n} arguments"
+    end
+    [n, out]
+  end
+
   def self.unexpose(name)
     entry = @objects ? @objects.delete(name.to_s) : nil
     entry[2].close if entry
@@ -517,6 +616,88 @@ module Asterism
     self
   end
 
+  # on_app_join { |node, app| }: an application of another node appeared
+  # (its token asterism/<node>/<app>); on_app_leave { |node, app| }: it is
+  # gone. A node may run several applications: each comes and goes on its
+  # own, and the node stays (on_join / on_leave) while one of them or an
+  # object is there. The applications there already join on the first
+  # polls after connecting; when the connection is lost, every application
+  # known until then leaves. Called from Asterism.poll, as on_join;
+  # Asterism.close forgets them.
+  def self.on_app_join(&blk)
+    raise ArgumentError, "on_app_join needs a block" unless blk
+    (@on_app_join ||= []) << blk
+    self
+  end
+
+  def self.on_app_leave(&blk)
+    raise ArgumentError, "on_app_leave needs a block" unless blk
+    (@on_app_leave ||= []) << blk
+    self
+  end
+
+  def self.off_app_join(blk)
+    @on_app_join.delete(blk) if @on_app_join
+    self
+  end
+
+  def self.off_app_leave(blk)
+    @on_app_leave.delete(blk) if @on_app_leave
+    self
+  end
+
+  # Compares the applications alive now with those told before and calls
+  # the on_app_* blocks for the difference (this application left out).
+  # @api private
+  def self.tell_apps
+    known = @known_apps
+    return if known.nil?
+    now = {}
+    if @session
+      own = "#{@node}/#{@app}"
+      keys = @apps.keys
+      i = 0
+      while i < keys.size
+        now[keys[i]] = true unless keys[i] == own
+        i += 1
+      end
+    end
+    joined = []
+    left = []
+    keys = now.keys
+    i = 0
+    while i < keys.size
+      joined << keys[i] unless known[keys[i]]
+      i += 1
+    end
+    keys = known.keys
+    i = 0
+    while i < keys.size
+      left << keys[i] unless now[keys[i]]
+      i += 1
+    end
+    @known_apps = @session ? now : nil
+    tell_apps_each("on_app_join", @on_app_join, joined)
+    tell_apps_each("on_app_leave", @on_app_leave, left)
+  end
+
+  # @api private
+  def self.tell_apps_each(where, blocks, names)
+    return if blocks.nil? || names.empty?
+    i = 0
+    while i < names.size
+      cut = names[i].index("/")
+      node = names[i][0, cut]
+      app = names[i][cut + 1, names[i].size]
+      j = 0
+      while j < blocks.size
+        tell(where, blocks[j], node, app)
+        j += 1
+      end
+      i += 1
+    end
+  end
+
   # Compares the nodes alive now with those told before and calls the
   # blocks for the difference.
   # @api private
@@ -527,6 +708,7 @@ module Asterism
     # the connection is neither new nor lost): nothing can have changed.
     return unless @nodes_changed
     @nodes_changed = false
+    tell_apps
     now = []
     now_set = {}
     if @session
@@ -580,10 +762,15 @@ module Asterism
     end
   end
 
-  # One block for one node (CRuby routes what it raises to on_error).
+  # One block for one node, or one application (CRuby routes what it
+  # raises to on_error).
   # @api private
-  def self.tell(_where, blk, node)
-    blk.call(node)
+  def self.tell(_where, blk, node, app = nil)
+    if app.nil?
+      blk.call(node)
+    else
+      blk.call(node, app)
+    end
   end
 
   # @api private
@@ -594,13 +781,36 @@ module Asterism
       lost("the connection was lost")
       return false
     end
+    back_again(s)
     answer_calls
     answer_profile
+    answer_status
     follow_liveliness
     !@session.nil?
   rescue Asterism::Zenoh::Error => e
-    lost(e.message)
-    false
+    lost_if_closed(e.message)
+    !@session.nil?
+  end
+
+  # After the binding opened a lost connection again: tell the profile and
+  # the status again (a put made while the router was away reached nobody).
+  # @api private
+  def self.back_again(s)
+    now = s.respond_to?(:reconnecting?) && s.reconnecting?
+    was = @was_reconnecting
+    @was_reconnecting = now
+    return unless was && !now
+    tell_profile
+    tell_status(true)
+  end
+
+  # A Zenoh error during a call or a poll: the connection is gone only when
+  # the session says it is closed. While the binding reconnects, the
+  # session (and everything declared on it) stays.
+  # @api private
+  def self.lost_if_closed(reason)
+    s = @session
+    lost(reason) if s.nil? || s.closed?
   end
 
   # Polls until the block is true. Answers incoming calls meanwhile.
@@ -764,7 +974,7 @@ module Asterism
       # The caller's node ID is the key's last chunk (docs/protocol.md 4.1).
       g = s.get("#{ROOT}/#{path}/call/#{@node}", timeout_ms: timeout_ms, payload: payload)
     rescue Asterism::Zenoh::Error => e
-      lost(e.message)
+      lost_if_closed(e.message)
       raise Disconnected, e.message
     end
     Future.new(path, method, g, now_ms + timeout_ms, timeout_ms)
@@ -797,7 +1007,7 @@ module Asterism
     begin
       g = session!.get("#{ROOT}/#{path}/meta", timeout_ms: timeout_ms)
     rescue Asterism::Zenoh::Error => e
-      lost(e.message)
+      lost_if_closed(e.message)
       raise Disconnected, e.message
     end
     f = Future.new(path, "meta", g, now_ms + timeout_ms, timeout_ms)
@@ -889,8 +1099,16 @@ module Asterism
     entry = @objects[name]
     return nil unless entry
     list = []
-    entry[1].each { |m, n| list << { "name" => m, "arity" => n } }
-    { "methods" => list }
+    info = entry[4] || {}
+    entry[1].each do |m, n|
+      e = { "name" => m, "arity" => n }
+      extra = info[m]
+      extra.each { |k, v| e[k] = v } if extra
+      list << e
+    end
+    out = { "methods" => list }
+    out["doc"] = entry[5] if entry[5]
+    out
   end
 
   MALFORMED = "malformed call (expected a map {\"method\" => name, \"args\" => [...], \"kwargs\" => {...}})"

data/mrblib/credentials.rb

@@ -0,0 +1,197 @@
+# The credentials of one node or router as one file: the .tar an Asterism
+# console hands out when it issues a certificate ("Save all (.tar)" on the
+# certificate page; the archive is made in the browser that made the key).
+# It holds, at its top or in one directory:
+#
+#   <name>.key      the private key (PKCS#8 PEM)
+#   <name>.pem      the certificate (its common name is <name>)
+#   ca.pem          the CA that signed it (and the router's certificate)
+#   zenoh.json5     an example configuration (for zenohd or another client)
+#   asterism.json   {"name": ..., "router": "tls/host:port", "not_after": ..., ...}
+#
+#   Asterism.connect(credentials: "/home/asterism/alice.tar", app: "game")
+#
+# The certificates go to zenoh as base64 (transport/link/tls/*_base64) with
+# enable_mtls, and the router's locator and the node ID come from
+# asterism.json unless given. This is the portable part, in plain Ruby for
+# the boards (mruby / PicoRuby: no Regexp, no pack, no File.binread): the
+# file is read whole and the tar taken apart with byteslice / getbyte.
+# CRuby replaces the reading and adds checks (lib/asterism/cruby/credentials.rb:
+# the standard library's tar reader, file modes, the key pair).
+module Asterism
+  class Credentials
+    # What a credentials file is missing or holds wrong.
+    class Error < ::Asterism::Error; end
+
+    TLS = "transport/link/tls"
+    # The largest file read (the real ones are a few KB).
+    MAX_SIZE = 1024 * 1024
+    BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+
+    attr_reader :path, :name, :kind, :router, :not_after, :key_pem, :cert_pem, :ca_pem, :info
+
+    # Reads path (a String of a .tar). warn: false skips the check of who
+    # may read the file (CRuby; the boards have no file modes).
+    def self.load(path, warn: true)
+      new(path, warn: warn)
+    end
+
+    # A credentials file (a path or a Credentials) and the arguments of a
+    # connection -> [locator, config Hash, credentials]. The locator given
+    # wins over asterism.json's router; config given (a Hash) is laid over
+    # the TLS keys. @api private
+    def self.merge(credentials, locator, config)
+      creds = credentials.is_a?(Credentials) ? credentials : load(credentials)
+      if config.is_a?(String)
+        raise ArgumentError, "credentials: and a config String cannot be combined; pass config: as a Hash"
+      end
+      merged = creds.zenoh_config
+      (config || {}).each { |k, v| merged[k] = v }
+      [locator || creds.router, merged, creds]
+    end
+
+    # {basename => content} of the regular files of a ustar archive (data,
+    # a String of its bytes), at its top or in one directory. @api private
+    def self.untar(data, path = "the file")
+      files = {}
+      pos = 0
+      total = data.bytesize
+      while pos + 512 <= total
+        break if data.getbyte(pos) == 0 # the end: blocks of zeros
+        name = field(data, pos, 100)
+        prefix = field(data, pos + 345, 155)
+        size_text = field(data, pos + 124, 12).strip
+        type = data.getbyte(pos + 156)
+        size = size_text.empty? ? 0 : size_text.to_i(8)
+        pos += 512
+        raise Error, "#{path}: not a tar file (a member runs past the end)" if pos + size > total
+        if type == 48 || type == 0 # '0' or NUL: a regular file
+          full = prefix.empty? ? name : "#{prefix}/#{name}"
+          base = full.split("/").last.to_s
+          raise Error, "#{path}: #{base} is in it twice" if files.key?(base)
+          files[base] = data.byteslice(pos, size) unless base.empty?
+        end
+        pos += (size + 511) / 512 * 512
+      end
+      raise Error, "#{path}: not a tar file with credentials in it" if files.empty?
+      files
+    end
+
+    # The text of a NUL-terminated header field. @api private
+    def self.field(data, pos, len)
+      n = 0
+      n += 1 while n < len && data.getbyte(pos + n) != 0
+      data.byteslice(pos, n).to_s
+    end
+
+    # base64 of s without line breaks (CRuby's [s].pack("m0")). @api private
+    def self.base64(s)
+      out = ""
+      n = s.bytesize
+      i = 0
+      while i < n
+        b0 = s.getbyte(i)
+        b1 = i + 1 < n ? s.getbyte(i + 1) : 0
+        b2 = i + 2 < n ? s.getbyte(i + 2) : 0
+        v = (b0 << 16) | (b1 << 8) | b2
+        out << BASE64[(v >> 18) & 63] << BASE64[(v >> 12) & 63]
+        out << (i + 1 < n ? BASE64[(v >> 6) & 63] : "=")
+        out << (i + 2 < n ? BASE64[v & 63] : "=")
+        i += 3
+      end
+      out
+    end
+
+    # The string fields of asterism.json without a JSON library (only for
+    # a build that has none). @api private
+    def self.json_strings(text)
+      h = {}
+      %w[format name kind router serial not_after fingerprint console issued_at].each do |k|
+        key = "\"#{k}\""
+        i = text.index(key)
+        next unless i
+        rest = text[i + key.size, text.size - i - key.size].to_s
+        colon = rest.index(":")
+        next unless colon
+        q1 = colon + 1
+        q1 += 1 while rest[q1] == " "
+        next unless rest[q1] == "\""
+        q2 = rest.index("\"", q1 + 1)
+        next unless q2
+        h[k] = rest[q1 + 1, q2 - q1 - 1]
+      end
+      h
+    end
+
+    def initialize(path, warn: true)
+      @path = path.to_s
+      check_mode if warn
+      files = read_tar
+      @info = parse_info(files["asterism.json"])
+      keys = files.keys.select { |f| f.end_with?(".key") }
+      raise Error, "#{@path}: no private key (<name>.key) in it" if keys.empty?
+      raise Error, "#{@path}: more than one private key in it (#{keys.sort.join(', ')})" if keys.size > 1
+      @name = @info["name"].to_s
+      @name = keys.first[0, keys.first.size - 4] if @name.empty?
+      @key_pem = files["#{@name}.key"] or raise Error, "#{@path}: the key is not named after #{@name} (#{keys.first})"
+      @cert_pem = files["#{@name}.pem"] or raise Error, "#{@path}: no certificate #{@name}.pem in it"
+      @ca_pem = files["ca.pem"] or raise Error, "#{@path}: no ca.pem in it"
+      @kind = @info["kind"]
+      @router = @info["router"].to_s.empty? ? nil : @info["router"].to_s
+      @not_after = @info["not_after"]
+      check_pair
+    end
+
+    # The zenoh configuration keys (a Hash for Session.open's config:):
+    # the CA, the certificate and the key as base64, and mutual TLS.
+    def zenoh_config
+      {
+        "#{TLS}/root_ca_certificate_base64" => b64(@ca_pem),
+        "#{TLS}/connect_certificate_base64" => b64(@cert_pem),
+        "#{TLS}/connect_private_key_base64" => b64(@key_pem),
+        "#{TLS}/enable_mtls" => true
+      }
+    end
+
+    def inspect
+      "#<Asterism::Credentials #{@name} #{@router || '(no router)'}#{@not_after ? " until #{@not_after}" : ''}>"
+    end
+    alias to_s inspect
+
+    private
+
+    def b64(pem)
+      Credentials.base64(pem)
+    end
+
+    # The boards have no file modes (CRuby warns like ssh).
+    def check_mode; end
+
+    # The key pair is checked by CRuby (openssl); on the boards the router
+    # refuses a wrong one.
+    def check_pair; end
+
+    def read_tar
+      data = begin
+        ::File.open(@path, "r") { |f| f.read }
+      rescue StandardError => e
+        raise Error, "#{@path}: #{e.message}"
+      end
+      raise Error, "#{@path}: cannot be read" if data.nil?
+      raise Error, "#{@path}: too large for a credentials file" if data.bytesize > MAX_SIZE
+      Credentials.untar(data, @path)
+    end
+
+    def parse_info(text)
+      return {} if text.nil?
+      return Credentials.json_strings(text) unless Object.const_defined?(:JSON)
+      h = ::JSON.parse(text)
+      raise Error, "#{@path}: asterism.json is not an object" unless h.is_a?(Hash)
+      h
+    rescue Error
+      raise
+    rescue StandardError => e
+      raise Error, "#{@path}: asterism.json: #{e.message}"
+    end
+  end
+end

data/mrblib/profile.rb

@@ -282,7 +282,7 @@ module Asterism
     begin
       g = session!.get("#{ROOT}/#{path}", timeout_ms: ms, params: icon ? nil : "icon=0")
     rescue Asterism::Zenoh::Error => e
-      lost(e.message)
+      lost_if_closed(e.message)
       raise Disconnected, e.message
     end
     Future.new(path, "profile", g, now_ms + ms, ms)