asterism 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b55c825f8859d86ba09baad0585c0f416a168023b8032c3f871d63bebef0538c
-  data.tar.gz: 4d6fd26b326e62348e4fba8c6881c48b5b7145dd0b0c701eb7ba1dcc1bf5b261
+  metadata.gz: ba14899dd37f9c4c21e148a2256d71545785da6f61a1f8f6701e2d0d189e9061
+  data.tar.gz: 207e08ed177ffa93cd5c7173a84c31f519f59c8e076c6c641ccaa8db27712ea9
 SHA512:
-  metadata.gz: 0acc8e1c4e4f028124d247a54e35ebda3451449dcfc46da503d345c857502200b1b68b4f15a4d59fbb7a603d9331f6996aa9072b1426e039fea87b43efbddd5e
-  data.tar.gz: 03b912800f24b881a7e01eb6479c2d8c3c2c32a3346538ea60ae5f65c431f3035e097f5fc90fdcaec7734efbf95496544c4b0dd174b12e6be20cabfec2db3635
+  metadata.gz: de0f85b8c36d4b3c991603004f151ea68952bd7fcc7fdbc76b992af80505b45be3612c5975e509e4f1415f553db8d91ea94940817c00768705bdbf1a011d45e6
+  data.tar.gz: df7634a6c9453fb647c0f148199ff056c646451e3c839ac5cf02704db0ee7dfa7508d8aabdd9fde8005b8909dd6c7217f2d2b96a6e066ac6895d39d9a2af9481

data/CHANGELOG.md

@@ -6,6 +6,46 @@ the earlier ones are only in this repository. From 0.4.0 the two Zenoh
 bindings (asterism-zenoh, picoruby-asterism-zenoh) carry the same minor
 version (a patch release of one may come without the other).
 
+## 0.6.0
+
+One connection for everything and a lighter `Asterism.poll`; every 0.5.x
+call works as before. Needs asterism-zenoh / picoruby-asterism-zenoh 0.4.0
+(unchanged).
+
+Added
+
+- `Asterism.session` (README "One connection"): the Zenoh session of
+  `Asterism.connect` (an `Asterism::Zenoh::Session`), for put, subscribe, a
+  ROS 2 node (`Asterism::ROS::Node.new(Asterism.session, ...)`) and the rest
+  of the Zenoh API on the same connection. `Disconnected` when not
+  connected. The session stays Asterism's: its `close` does nothing (it
+  warns once); `Asterism.close` and a lost connection close it, with
+  everything declared on it. A router that lets a one-time password in
+  once now takes such an application, and its ROS 2 node has the node's
+  Zenoh ID (a console draws it inside the node).
+- The CRuby API: `net.session`, the same session as a `Zenoh::Connection`
+  on the `Net`'s receiving thread (`shared?`; its `close` does nothing);
+  `Asterism::ROS::Connection.new(net.session)` makes ROS 2 nodes on it, and
+  its `close` withdraws only its nodes. `Zenoh::Connection#shared?`.
+  `ROS::Node#close` on a `ROS::Connection` also stops polling the node.
+- `rake bench:poll` (`test/bench_poll.rb`): the time and the allocations
+  of one `Asterism.poll` by the number of nodes and objects.
+- Tests: `test/test_session.rb`, `test/test_api_session.rb`, and on mruby
+  `host_test/test_session.rb` with `host_test/peer.rb` (the mruby test
+  build adds mruby-eval for the ROS 2 type files).
+
+Changed
+
+- `Asterism.poll` does less when nothing came: each queue (calls, profile
+  queries, liveliness) is read only when its count is not zero, and the
+  list of nodes and the comparison behind `on_join` / `on_leave` are made
+  again only after a liveliness change, with Hashes instead of `include?`.
+  The behaviour is the same (the order and number of the `on_join` /
+  `on_leave` calls, the order of `Asterism.nodes`). With 4 other nodes and
+  5 objects, a poll in which nothing changed: CRuby 3.2 us and 49
+  allocations -> 0.6 us and 7; mruby (host) 14-17 us -> 2.2 us.
+  `Asterism.each` drops duplicates with a Hash.
+
 ## 0.5.0
 
 Node profiles; every 0.4.x call works as before. Needs asterism-zenoh /

data/README.md

@@ -13,8 +13,8 @@ repository holds the pure Ruby layers, written once for every Ruby:
 | `data/icon.png` | CRuby's default profile icon (32x32 PNG; [Profiles](#profiles)) |
 | `data/msgs/` | ROS 2 message types generated from ROS 2 Jazzy's definitions (Apache-2.0; tf2_msgs BSD-3-Clause; see NOTICE) |
 | `tools/` | The type generator `asterism_msggen.rb`, the Jazzy definitions it reads, `ros2_types.rb` (refreshes them from a ROS 2 image) |
-| `test/` | `test/msgs` (types, CDR; CRuby only), `test_asterism.rb` (objects and ROS between CRuby sessions), `test_profile.rb` (node profiles), `test_api_*.rb` (the CRuby API) |
-| `host_test/` | `rake test:mruby`: the shared layer on mruby (profiles between two mruby processes) |
+| `test/` | `test/msgs` (types, CDR; CRuby only), `test_asterism.rb` (objects and ROS between CRuby sessions), `test_profile.rb` (node profiles), `test_session.rb` (`Asterism.session`, `on_join` / `on_leave`), `test_api_*.rb` (the CRuby API), `bench_poll.rb` (`rake bench:poll`) |
+| `host_test/` | `rake test:mruby`: the shared layer on mruby (profiles between two mruby processes; `Asterism.session`, `on_join` / `on_leave` and the time of a poll against `peer.rb`) |
 | `examples/` | CRuby: `node.rb` (objects with a board), `node_polled.rb` (the same with the portable API of the boards), `ros2_talker.rb` (topics, a timer, services with ROS 2), `ros2_rover.rb` (drive a ROS 2 robot: `/cmd_vel`, `/odom`, `/imu`), `zenoh.rb` (plain Zenoh), `mujoco/` (MuJoCo run from CRuby through Fiddle, its robot exposed as Asterism objects; see its README) |
 
 The Zenoh binding underneath is a separate gem with the same Ruby API on
@@ -39,7 +39,10 @@ asterism-zenoh too). What changed in each version is in
 ([docs/api_review.md](docs/api_review.md)) and only adds and deprecates
 (see [Deprecations and 1.0](#deprecations-and-10)); 0.5.0 adds node
 profiles ([Profiles](#profiles): what a node runs on, where, a name and an
-icon).
+icon); 0.6.0 adds `Asterism.session`
+([One connection](#one-connection-asterismsession): the object layer's
+session for plain Zenoh and ROS 2 too) and makes `Asterism.poll` cheap when
+nothing changed.
 
 ## Which API?
 
@@ -59,6 +62,7 @@ Entry points and what they give:
 | `Asterism::Zenoh::Session.open` | a `Session` (portable) | zenoh-c / zenoh-pico |
 | `Asterism::Zenoh.open` | a `Zenoh::Connection` (CRuby) | `c.session` is the `Session` |
 | `Asterism.connect` | `Asterism` itself (portable; one connection per process or VM), or a `Net` to the block (CRuby) | a `Session` of its own |
+| `Asterism.session` | that `Session` (portable), for put, subscribe and a ROS 2 node on the same connection; `net.session` is it as a `Zenoh::Connection` (CRuby) | the object layer's (Asterism closes it) |
 | `Asterism::ROS::Node.new(session, ...)` | a `Node` (portable) | the `Session` given |
 | `Asterism::ROS.connect` | a `ROS::Connection` (CRuby) | `ros.zenoh` is the `Zenoh::Connection` |
 
@@ -87,7 +91,7 @@ build but not yet tested. To install from the repositories instead:
 
 ```
 (cd ../asterism-zenoh && rake gem) && rake gem
-gem install --local ../asterism-zenoh/pkg/asterism-zenoh-0.4.0.gem pkg/asterism-0.5.0.gem
+gem install --local ../asterism-zenoh/pkg/asterism-zenoh-0.4.0.gem pkg/asterism-0.6.0.gem
 ```
 
 From the working trees, without installing:
@@ -116,6 +120,7 @@ rake test:objects     # objects and Asterism::ROS between CRuby sessions over a
 rake test:api         # the CRuby API (blocks, receiving threads, Enumerators)
 ASTERISM_TEST_ROUTER=tcp/127.0.0.1:7447 rake test:objects test:api   # the same through a zenohd router
 rake test:mruby       # the shared layer on mruby (builds mruby; not part of `rake`)
+rake bench:poll       # the time and allocations of one Asterism.poll by nodes and objects (prints a table)
 ```
 
 `test:mruby` builds mruby with picoruby-asterism-zenoh and this gem
@@ -252,6 +257,7 @@ end
 | `net.on_join { \|node\| }` / `net.on_leave { \|node\| }` | `Asterism.on_join` / `on_leave` of the portable API (the same blocks, told from `Asterism.poll`), here on the receiving thread; what they raise goes to `on_error`. `net.off_join(proc)` / `off_leave(proc)` remove one |
 | `net.start` / `stop` / `run` / `running?` / `on_error` | as for Zenoh. A method of an exposed object that raises is answered to its caller as a `RemoteError`, as before; `on_error` gets what `on_join` / `on_leave` raise |
 | `net.profile(**fields)` / `net.profile_of(node, icon: true, timeout: 2.0)` | `Asterism.profile` / `profile_of` ([Profiles](#profiles)); `profile_of` waits for the receiving thread's ticks while it runs |
+| `net.session` | `Asterism.session` as a `Zenoh::Connection` (`subscribe { }`, `put`, `publisher`, ...) on this receiving thread: its blocks run there, between the calls answered. `shared?` is true; its `close` does nothing and `start` / `stop` / `run` are the `Net`'s. A ROS 2 node on it: `Asterism::ROS::Connection.new(net.session).node("name")`. See [One connection](#one-connection-asterismsession) |
 | `net.nodes`, `node_id`, `app`, `connected?`, `lost_reason`, `poll`, `close` | |
 
 ### Over TLS (a router on the internet)
@@ -307,6 +313,7 @@ end
 | `node.call(name, type, request = nil, request:, timeout: 2.0, **fields)` | waits for the response. Here `timeout:` is always the time limit (see [Reserved keywords](#reserved-keywords)) |
 | `ros.spin` (`run`) / `start` / `stop` / `running?` / `on_error` / `close` | |
 | `ros.zenoh` | the `Asterism::Zenoh::Connection` underneath (same receiving thread) |
+| `Asterism::ROS::Connection.new(net.session, domain: 0)` | nodes on the object layer's session (the same Zenoh ID as the objects), spun by the `Net`'s receiving thread. Its `close` withdraws its nodes only |
 
 `type` is a generated type or its name (`"geometry_msgs/msg/Twist"`).
 Messages and `Attachment` take part in pattern matching (`deconstruct_keys`,
@@ -412,7 +419,7 @@ Asterism.nodes                            # => ["linux", "fmruby-bbbbbb"]
 | `Asterism.connect(locator, node:, app:, mode: nil, listen: nil, config: nil, connect_timeout: nil, check_timeout: 1.5)` | `Asterism` | `locator`, `mode:`, `listen:` (and `config:` / `connect_timeout:` when given, CRuby only: TLS and the rest of zenoh's configuration; the boards raise `ArgumentError`) go to `Asterism::Zenoh::Session.open` (client of a router by default; `mode: :peer` with or without `listen:` without one). `node:` is this machine's ID, `app:` the application's name (one key chunk each: no `/ * $ ? #`, not starting with `@`; else `ArgumentError`). `Disconnected` when it cannot connect; `Error` when objects of the same `<node>/<app>` are already alive (a second copy of the application), or when already connected. Waits up to `check_timeout:` seconds for that check (a router answers at once; give more over a slow relay). Returns the module itself: on a board the module is the connection (one per application). The default is plain text without authentication; see [Over TLS](#over-tls-a-router-on-the-internet). |
 | `Asterism.expose(name, obj, methods:)` | `"<node>/<app>/<name>"` | `methods:` is an Array of names, or a Hash `name => number of arguments` (checked before the call; `-1` or the Array form: any). `ArgumentError` when `obj` has no such public method. Exposing a name again replaces it. |
 | `Asterism.unexpose(name)` | true / false | |
-| `Asterism.poll` | true / false | Call from the update loop: polls Zenoh, answers the calls that came in, follows who is alive and calls the `on_join` / `on_leave` blocks. `false` once the connection is closed or lost. |
+| `Asterism.poll` | true / false | Call from the update loop: polls Zenoh, answers the calls that came in, follows who is alive and calls the `on_join` / `on_leave` blocks. `false` once the connection is closed or lost. Cheap when nothing came (0.6.0): each queue is looked at by its count, and the list of nodes is made again only after a liveliness change. |
 | `Asterism.on_join { \|node\| }` / `Asterism.on_leave { \|node\| }` | `Asterism` | Another node appeared (its node token or one of its objects) / is gone (no token and no object left). The nodes there already join on the first polls after connecting; when the connection is lost, every node known until then leaves (on the next `Asterism.poll`). The blocks run from `Asterism.poll` only, never from the polling inside a waiting call; what they raise comes out of `Asterism.poll`. Each call adds a block; `Asterism.off_join(proc)` / `off_leave(proc)` remove one; `Asterism.close` forgets them (a lost connection does not). |
 | `Asterism[path, timeout: 2.0]` | `Proxy` | `path` is `<node>/<app>/<object>` without wildcards (`ArgumentError`). `timeout:` (seconds) or `timeout_ms:` is the time limit of its calls. Nothing is sent until a method is called. |
 | `proxy.<method>(*args, **kw)` | the remote return value | Waits for the answer (the proxy's time limit). `RemoteError` when it raised there or could not be called (not exposed: `NoMethodError`; wrong number of arguments: `ArgumentError`; no such object: `NameError`), `TimeoutError` when no answer came in time (also at once when nobody answers that key), `Disconnected`, `EncodeError` (before anything is sent) for a value MessagePack cannot carry. A block cannot be sent (`ArgumentError`). |
@@ -424,6 +431,7 @@ Asterism.nodes                            # => ["linux", "fmruby-bbbbbb"]
 | `Asterism.each(pattern = "**") { \|proxy\| }` | count (Array without a block) | The exposed objects alive now (this application's own included) whose `<node>/<app>/<object>` matches; `*` is one chunk, `**` any number. 1.0 returns the proxies from the block form instead of their number (Ruby's `each` returns its receiver); write `Asterism.each(pattern).size` for the count. |
 | `Asterism.nodes` | `[String]` | Node IDs alive now, this one first. |
 | `Asterism.connected?` / `node_id` / `app` / `exposed` / `lost_reason` | | |
+| `Asterism.session` | `Asterism::Zenoh::Session` | The connection's own session, for put / subscribe / a ROS 2 node on the same connection ([One connection](#one-connection-asterismsession)). The same object until the connection closes. `Disconnected` when not connected. Its `close` does nothing (warns once); `Asterism.close` closes it. |
 | `Asterism.close` | nil | Withdraws every exposed object. Idempotent. |
 | `Asterism.profile(kind:, name:, host:, icon:)` / `Asterism.profile` | Hash | This node's profile: sets the fields given and returns it; without arguments, returns it. See [Profiles](#profiles). |
 | `Asterism.profile_of(node, icon: true, timeout: 2.0)` | Hash or nil | Another node's profile, nil when it does not answer (an older version, a ROS 2 node). |
@@ -480,6 +488,59 @@ Asterism.profile_of("an-older-node")                 # => nil
   an acceptable PNG (nil otherwise), for a tool that wants to check an icon
   first.
 
+## One connection: `Asterism.session`
+
+An application that also puts, subscribes or runs a ROS 2 node uses the
+object layer's own session for it (0.6.0) instead of opening a second one:
+
+```ruby
+Asterism.connect("tcp/192.0.2.2:7447", node: "fmruby-aaaaaa", app: "game")
+Asterism.expose("othello", game, methods: [:move, :state])
+s = Asterism.session                                    # an Asterism::Zenoh::Session
+s.put("asterism/fmruby-aaaaaa/game/othello/state", MessagePack.pack(state))
+moves = s.subscribe("asterism/*/game/othello/state")    # moves.each_pending in the update loop
+node = Asterism::ROS::Node.new(s, "brain")               # a ROS 2 node with the same Zenoh ID
+cmd = node.publisher("/cmd_vel", "geometry_msgs/msg/Twist")
+# update loop: Asterism.poll; node.poll
+```
+
+CRuby API:
+
+```ruby
+Asterism.connect(router, node: "mypc", app: "demo") do |net|
+  net.session.subscribe("asterism/*/game/**") { |sample| p sample.key }   # on the receiving thread
+  ros = Asterism::ROS::Connection.new(net.session)
+  ros.node("brain").subscribe("/odom", "nav_msgs/msg/Odometry") { |odom| puts odom.pose.pose.position.x }
+  net.run
+end
+```
+
+- **Why one.** A router that lets each pass in once (a one-time password
+  at a `wss://` door) lets only the first session in; and a ROS 2 node on
+  the object layer's session has the node's Zenoh ID, so a console draws it
+  inside the node.
+- **Who closes it.** The session is Asterism's. `Asterism.session.close`
+  (and `net.session.close`) does nothing but warn once, so a library handed
+  the session cannot break the connection. `Asterism.close`, the end of the
+  connect block and a lost connection close it, and with it everything
+  declared on it: the application's subscribers, publishers, ROS 2 nodes.
+  Close those yourself when you are done with them earlier (`sub.close`,
+  `node.close`; on CRuby `ros.close` withdraws its nodes and leaves the
+  rest).
+- **After a lost connection** (`Asterism.poll` returned false), connect
+  again, take `Asterism.session` again (a new object) and declare again
+  what you had on the old one.
+- **Polling.** `Asterism.poll` polls the session; `node.poll` polls it too
+  and only then serves the node. Each subscriber, queryable and node keeps
+  what came for it, so the order does not matter and nothing is taken from
+  another. Your own `put` does not come back to your own subscriber on the
+  same session.
+- **Keys.** Keep your keys out of the object layer's: `asterism/<node>/<app>/**`
+  is answered by its queryable (`get` there is a call), `asterism/<node>` and
+  `asterism/<node>/<app>/<object>` are its liveliness tokens. Putting under
+  `asterism/<node>/<app>/<object>/<anything>` (a state, a log) is fine:
+  puts and subscriptions do not meet queryables or liveliness.
+
 ## Errors
 
 Every error Asterism raises is an `Asterism::Error` (a `StandardError`):
@@ -591,7 +652,9 @@ Asterism follows `Asterism::Zenoh`: the connection is closed when the router
 why, and calls raise `Asterism::Disconnected`. **`Asterism::Zenoh::Error`
 never comes out of Asterism; it is always wrapped in `Disconnected`** (the
 message is kept). The exposed objects are gone with the connection: to go
-on, the application calls `connect` and `expose` again.
+on, the application calls `connect` and `expose` again, and declares again
+what it had on `Asterism.session` (subscribers, ROS 2 nodes; the old
+session is closed, its entities raise `Zenoh::ClosedError`).
 
 ## Values
 
@@ -610,7 +673,7 @@ caller gets `RemoteError` (`Asterism::EncodeError`). Nesting is limited to
 | `asterism/<node>/<app>/<object>/meta` | get / queryable | reply: `{"methods" => [[name, arity], ...]}` (arity `-1` when not declared). The object may be `*` in the query: one reply per object |
 | `asterism/<node>` | liveliness | the node is connected |
 | `asterism/<node>/<app>/<object>` | liveliness | the object is exposed |
-| `asterism/<node>/@profile` | get / queryable, and put | query (parameter `icon=0` for no icon): reply the node's profile, a Hash (`kind`, `host`, `name`, `icon`, `icon_hash`; [Profiles](#profiles)). The node also puts the profile without the icon at connect and on each change. `@profile` is a verbatim chunk, so `asterism/**` does not match it: the object layer's wildcards never see it. An application's own profile would go at `asterism/<node>/<app>/@profile` (not in 0.5.0) |
+| `asterism/<node>/@profile` | get / queryable, and put | query (parameter `icon=0` for no icon): reply the node's profile, a Hash (`kind`, `host`, `name`, `icon`, `icon_hash`; [Profiles](#profiles)). The node also puts the profile without the icon at connect and on each change. `@profile` is a verbatim chunk, so `asterism/**` does not match it: the object layer's wildcards never see it. An application's own profile would go at `asterism/<node>/<app>/@profile` (not in 0.6.0) |
 
 One queryable per application (`asterism/<node>/<app>/**`), and one for the
 profile (`asterism/<node>/@profile`). A call whose

data/lib/asterism/cruby/objects.rb

@@ -27,7 +27,7 @@ module Asterism
   # singleton class, so the shared methods themselves are not changed.
   module Locked
     %i[expose unexpose poll nodes [] call_async meta connected? exposed on_join on_leave off_join off_leave
-       profile profile_async].each do |m|
+       profile profile_async session].each do |m|
       define_method(m) do |*args, **kw, &blk|
         ::Asterism::LOCK.synchronize { super(*args, **kw, &blk) }
       end
@@ -130,6 +130,21 @@ module Asterism
       @runner.add { ::Asterism.poll ? 0 : false }
     end
 
+    # Asterism.session as a Zenoh::Connection (the block API of
+    # Asterism::Zenoh.open) on the same receiving thread as the objects:
+    # subscribe / queryable blocks run there, between the calls answered.
+    # For a ROS 2 node on the same session:
+    # Asterism::ROS::Connection.new(net.session).node("name"). The session
+    # stays Asterism's: net.session.close does nothing (shared?), net.close
+    # closes it. Disconnected when not connected.
+    def session
+      ::Asterism::LOCK.synchronize do
+        s = ::Asterism.session
+        @session = nil if @session && !@session.session.equal?(s)
+        @session ||= ::Asterism::Zenoh::Connection.new(s, runner: @runner)
+      end
+    end
+
     def node_id = ::Asterism.node_id
     def app = ::Asterism.app
     def connected? = ::Asterism.connected?

data/lib/asterism/cruby/ros.rb

@@ -95,12 +95,15 @@ module Asterism
         self
       end
 
-      # Stops spinning, withdraws the nodes and closes the session.
+      # Stops spinning, withdraws the nodes and closes the session. On
+      # Asterism's session (ROS::Connection.new(net.session)) it only
+      # withdraws the nodes: the receiving thread and the session stay the
+      # object layer's.
       def close
-        runner.stop
+        runner.stop unless @zenoh.shared?
         @nodes.each { |n| n.close rescue ::Asterism::Zenoh::Error }
         @nodes = []
-        @zenoh.close
+        @zenoh.close unless @zenoh.shared?
         nil
       end
 
@@ -142,8 +145,17 @@ module Asterism
 
       def asterism_runner = @asterism_runner
 
+      # Withdraws the node and stops polling it.
+      def close
+        @asterism_runner.lock.synchronize do
+          super
+          @asterism_runner.remove(@asterism_task) if @asterism_task
+          @asterism_task = nil
+        end
+      end
+
       # The calls that change the node take the connection's lock.
-      %i[subscription client close every cancel_timer].each do |m|
+      %i[subscription client every cancel_timer].each do |m|
         define_method(m) do |*args, **kw, &blk|
           @asterism_runner.lock.synchronize { super(*args, **kw, &blk) }
         end

data/lib/asterism/cruby/zenoh.rb

@@ -158,11 +158,29 @@ module Asterism
     class Connection
       attr_reader :session, :runner
 
-      def initialize(session, interval: Runner::DEFAULT_INTERVAL)
+      # runner: an existing Runner to receive on instead of a new one
+      # (Asterism::Net#session gives the object layer's: the session and
+      # its receiving thread are Asterism's, see shared?). @api private
+      def initialize(session, interval: Runner::DEFAULT_INTERVAL, runner: nil)
         @session = session
-        @runner = Runner.new(session, interval: interval, name: "zenoh")
-        # The first task: false (the runner stops) once the session closed.
-        @runner.add { @session.poll ? 0 : false }
+        if runner
+          @runner = runner
+          @shared = true
+        else
+          @runner = Runner.new(session, interval: interval, name: "zenoh")
+          # The first task: false (the runner stops) once the session closed.
+          @runner.add { @session.poll ? 0 : false }
+          @shared = false
+        end
+      end
+
+      # True for the Connection of Asterism's own session (net.session):
+      # its close does nothing, start / stop / run are the object layer's
+      # receiving thread (net.start / net.stop / net.run), and
+      # Asterism.close (or the end of the connect block) closes the session
+      # with everything declared on it.
+      def shared?
+        @shared
       end
 
       # opts: those of Session#put (attachment:, encoding:, priority:,
@@ -370,15 +388,23 @@ module Asterism
       def declare_keyexpr(key) = @session.declare_keyexpr(key)
 
       # Stops receiving and closes the session (with everything declared on
-      # it). Idempotent.
+      # it). Idempotent. On a shared? Connection (net.session) it does
+      # nothing: close what you declared on it (subscriptions, publishers,
+      # ROS nodes) one by one, or let Asterism.close close them.
       def close
+        if @shared
+          ::Asterism.warn_once(self, "asterism: net.session belongs to Asterism; its close is ignored " \
+                                     "(net.close closes it)")
+          return nil
+        end
         @runner.close
         @session.close
         nil
       end
 
       def inspect
-        "#<Asterism::Zenoh::Connection #{closed? ? 'closed' : zid}#{running? ? ' running' : ''}>"
+        "#<Asterism::Zenoh::Connection #{closed? ? 'closed' : zid}#{@shared ? ' shared' : ''}" \
+          "#{running? ? ' running' : ''}>"
       end
 
       private

data/lib/asterism/version.rb

@@ -1,6 +1,6 @@
 module Asterism
   # The gem's version (the CRuby gem asterism). The Zenoh binding it needs
-  # is in asterism.gemspec (asterism-zenoh ~> 0.4.0 for 0.5.0: the bindings
-  # did not change; see CHANGELOG.md).
-  VERSION = "0.5.0"
+  # is in asterism.gemspec (asterism-zenoh ~> 0.4.0 for 0.5.0 and 0.6.0:
+  # the bindings did not change; see CHANGELOG.md).
+  VERSION = "0.6.0"
 end

data/mrblib/asterism.rb

@@ -227,16 +227,20 @@ module Asterism
       s.close
       raise Disconnected, e.message
     end
+    s.extend(SharedSession) # Asterism.session: the application's close does not close it
     @session = s
     @node = node
     @app = app
     @objects = {}  # name => [object, {method name => arity}, token]
-    @alive = {}    # "node/app/object" => true (from liveliness)
+    @alive = {}    # "node/app/object" => node (from liveliness)
     @nodes = {}    # node => true (from liveliness)
     @proxies = {}
     @depth = 0
     @lost = nil
     @known = []    # the other nodes told to on_join so far
+    @known_set = {} # the same, as node => true
+    @node_list = [node] # what nodes returns (this node first), rebuilt on a change
+    @nodes_changed = false # liveliness changed since tell_nodes last compared
     tell_profile   # for those who follow the profiles (the reply is the queryable's)
     self
   end
@@ -298,20 +302,67 @@ module Asterism
     @objects = {}
     @alive = {}
     @nodes = {}
+    @node_list = nil
+    @nodes_changed = true
     @proxies = {}
-    s.close if s
+    if s
+      @releasing = s
+      begin
+        s.close
+      ensure
+        @releasing = nil
+      end
+    end
     @node_token = nil
     @queryable = nil
     @watch = nil
     @profile_queryable = nil
   end
 
-  # @api private
+  # The Zenoh session of the connection (an Asterism::Zenoh::Session), for
+  # what the object layer does not do: put and subscribe, a ROS 2 node
+  # (Asterism::ROS::Node.new(Asterism.session, ...)), anything of the
+  # Zenoh API. One connection for everything: on a router that lets each
+  # pass in once, a second session would not get in, and a ROS 2 node on
+  # this session is part of this node (the same Zenoh ID).
+  #
+  # The session stays Asterism's: its close does nothing (it warns once);
+  # Asterism.close closes it, and with it everything declared on it (the
+  # application's subscribers, publishers, ROS 2 nodes). After a lost
+  # connection and a new Asterism.connect, take Asterism.session again and
+  # declare those again. Polling it (session.poll, node.poll) is fine:
+  # Asterism.poll polls it too, each entity keeps what came for it.
+  # Raises Disconnected when not connected (as the calls do).
+  def self.session
+    raise Disconnected, (@lost || "not connected") unless connected?
+    @session
+  end
+
+  # @api private (the name before 0.6.0; Asterism.session is the same)
   def self.session!
     raise Disconnected, (@lost || "not connected") unless @session
     @session
   end
 
+  # Whether Asterism itself is closing s (SharedSession#close).
+  # @api private
+  def self.releasing?(s)
+    !@releasing.nil? && @releasing.equal?(s)
+  end
+
+  # Extended onto the session of Asterism.connect: the session belongs to
+  # Asterism, so a close from anyone else (the application, a library that
+  # was handed Asterism.session) does nothing. Asterism.close and a lost
+  # connection close it.
+  module SharedSession
+    def close
+      return super if ::Asterism.releasing?(self)
+      ::Asterism.warn_once(self, "asterism: Asterism.session belongs to Asterism; its close is ignored " \
+                                 "(Asterism.close closes it)")
+      nil
+    end
+  end
+
   # The connection went away: closed, but the next Asterism.poll still tells
   # on_leave about every node known until then.
   # @api private
@@ -361,6 +412,10 @@ module Asterism
   # Call from the application's update loop. Answers the calls that came
   # in, follows who is alive and calls the on_join / on_leave blocks. false
   # once the connection is closed.
+  #
+  # Cheap when nothing came: each queue is looked at by its count first,
+  # and the list of nodes (and the comparison behind on_join / on_leave)
+  # is made again only after a liveliness change.
   def self.poll
     ok = @session ? pump : false
     tell_nodes
@@ -408,14 +463,43 @@ module Asterism
   def self.tell_nodes
     known = @known
     return if known.nil?
-    now = @session ? nodes : []
-    now.shift if @session # this node
+    # Nothing came on the liveliness watch since the last comparison (and
+    # the connection is neither new nor lost): nothing can have changed.
+    return unless @nodes_changed
+    @nodes_changed = false
+    now = []
+    now_set = {}
+    if @session
+      list = node_list
+      i = 1 # list[0] is this node
+      while i < list.size
+        n = list[i]
+        now << n
+        now_set[n] = true
+        i += 1
+      end
+    end
+    known_set = @known_set || {}
     joined = []
     left = []
-    now.each { |n| joined << n unless known.include?(n) }
-    known.each { |n| left << n unless now.include?(n) }
+    i = 0
+    while i < now.size
+      joined << now[i] unless known_set[now[i]]
+      i += 1
+    end
+    i = 0
+    while i < known.size
+      left << known[i] unless now_set[known[i]]
+      i += 1
+    end
     # After a loss, everything has been told: nothing more to compare.
-    @known = @session ? now : nil
+    if @session
+      @known = now
+      @known_set = now_set
+    else
+      @known = nil
+      @known_set = nil
+    end
     tell_each("on_join", @on_join, joined)
     tell_each("on_leave", @on_leave, left)
   end
@@ -493,9 +577,10 @@ module Asterism
   # @api private
   def self.follow_liveliness
     w = @watch
-    return unless w
+    return unless w && w.pending > 0
     # Array forms instead of blocks called from C (see Future#collect).
     events = w.each_pending
+    @nodes_changed = true if events.size > 0
     if events.size > 0 && w.dropped > 0
       warn_once(w, "asterism: #{w.dropped} liveliness changes dropped (more than #{watch_depth} at once); " \
                    "Asterism.each and Asterism.nodes may miss some objects")
@@ -515,24 +600,49 @@ module Asterism
         end
       elsif parts.size == 3
         if alive
-          @alive[rest] = true
+          @alive[rest] = parts[0]
         else
           @alive.delete(rest)
         end
       end
     end
+    @node_list = nil
   end
 
   # The node IDs alive now, this one first.
   def self.nodes
     return [] unless @session
+    node_list.dup
+  end
+
+  # The list behind nodes, made again only after a liveliness change (the
+  # caller must not change it). @api private
+  def self.node_list
+    list = @node_list
+    return list if list
     list = [@node]
-    @nodes.each_key { |n| list << n unless list.include?(n) }
-    @alive.each_key do |path|
-      n = path.split("/")[0]
-      list << n unless list.include?(n)
+    seen = { @node => true }
+    names = @nodes.keys
+    i = 0
+    while i < names.size
+      n = names[i]
+      unless seen[n]
+        seen[n] = true
+        list << n
+      end
+      i += 1
     end
-    list
+    owners = @alive.values
+    i = 0
+    while i < owners.size
+      n = owners[i]
+      unless seen[n]
+        seen[n] = true
+        list << n
+      end
+      i += 1
+    end
+    @node_list = list
   end
 
   # The exposed objects alive now whose <node>/<app>/<object> matches the
@@ -543,11 +653,15 @@ module Asterism
   def self.each(pattern = "**")
     paths = []
     if @session
+      seen = {}
       @objects.each_key do |name|
         path = "#{@node}/#{@app}/#{name}"
-        paths << path if glob?(pattern, path)
+        if glob?(pattern, path)
+          paths << path
+          seen[path] = true
+        end
       end
-      @alive.each_key { |path| paths << path if glob?(pattern, path) && !paths.include?(path) }
+      @alive.each_key { |path| paths << path if !seen[path] && glob?(pattern, path) }
     end
     proxies = paths.map { |path| self[path] }
     return proxies unless block_given?
@@ -619,7 +733,7 @@ module Asterism
   # @api private
   def self.answer_calls
     qa = @queryable
-    return unless qa
+    return unless qa && qa.pending > 0
     # Without a block, so that a handler that waits (and so polls) does not
     # re-enter the queryable's iteration.
     queries = qa.each_pending

data/mrblib/profile.rb

@@ -342,7 +342,7 @@ module Asterism
   # @api private
   def self.answer_profile
     qa = @profile_queryable
-    return unless qa
+    return unless qa && qa.pending > 0
     queries = qa.each_pending
     i = 0
     while i < queries.size

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: asterism
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Katsuhiko Kageyama