solid_objects 0.12.0 → 0.13.0

data/lib/solid_objects/web/route.rb

@@ -0,0 +1,55 @@
+# rbs_inline: enabled
+
+module SolidObjects
+  class Web
+    class Route
+      # A named segment stops at the next slash, so `/instances/:id` never
+      # swallows `/instances/1/pause` and route order cannot hide a page.
+      NAMED_SEGMENT = %r{/([^/]*):([^.:$/]+)}
+      SEGMENT_CAPTURE = '/\1(?<\2>[^$/]+)'
+
+      # @rbs @matcher: String | Regexp
+      # @rbs @request_method: String
+      # @rbs @pattern: String
+      # @rbs @policy: Hash[Symbol, String]
+      # @rbs @handler: Proc
+
+      attr_reader :request_method, :pattern, :policy, :handler
+
+      # @rbs (request_method: String, pattern: String, policy: Hash[Symbol, String], handler: Proc) -> void
+      def initialize(request_method:, pattern:, policy:, handler:)
+        @request_method = request_method
+        @pattern = pattern
+        @policy = policy
+        @handler = handler
+        @matcher = compile(pattern)
+      end
+
+      # @rbs (String) -> bool
+      def match?(path)
+        return @matcher == path if @matcher.is_a?(String)
+
+        @matcher.match?(path)
+      end
+
+      # @rbs (String) -> Hash[Symbol, String?]
+      def capture(path)
+        return {} if @matcher.is_a?(String)
+
+        match = @matcher.match(path)
+        return {} unless match
+
+        match.named_captures.transform_keys(&:to_sym)
+      end
+
+      private
+
+      # @rbs (String) -> (String | Regexp)
+      def compile(pattern)
+        return pattern unless pattern.match?(NAMED_SEGMENT)
+
+        Regexp.new("\\A#{pattern.gsub(NAMED_SEGMENT, SEGMENT_CAPTURE)}\\z")
+      end
+    end
+  end
+end

data/lib/solid_objects/web/router.rb

@@ -0,0 +1,46 @@
+# rbs_inline: enabled
+
+module SolidObjects
+  class Web
+    # Declares the pages of the dashboard. Every route carries the
+    # administration policy it needs, and a route declared without one raises
+    # at load time. A new page therefore cannot reach the database before an
+    # application has said who may read it.
+    module Router
+      # @rbs (String, policy: Hash[Symbol, String]?) { () -> untyped } -> void
+      def head(path, policy: nil, &handler)
+        route("HEAD", path, policy:, &handler)
+      end
+
+      # @rbs (String, policy: Hash[Symbol, String]?) { () -> untyped } -> void
+      def get(path, policy: nil, &handler)
+        route("GET", path, policy:, &handler)
+      end
+
+      # @rbs (String, policy: Hash[Symbol, String]?) { () -> untyped } -> void
+      def post(path, policy: nil, &handler)
+        route("POST", path, policy:, &handler)
+      end
+
+      # @rbs (String, String, policy: Hash[Symbol, String]?) { () -> untyped } -> void
+      def route(request_method, path, policy: nil, &handler)
+        raise ArgumentError, "route #{path} requires an authorization policy" unless policy
+        raise ArgumentError, "route #{path} requires a handler" unless handler
+        raise ArgumentError, "route #{path} requires a policy action" unless policy[:action]
+        raise ArgumentError, "route #{path} requires a policy resource" unless policy[:resource]
+
+        routes[request_method] << Route.new(request_method:, pattern: path, policy:, handler:)
+      end
+
+      # @rbs () -> Hash[String, Array[Route]]
+      def routes
+        @routes ||= Hash.new { |store, request_method| store[request_method] = [] }
+      end
+
+      # @rbs (String, String) -> Route?
+      def match(request_method, path)
+        routes[request_method].find { |route| route.match?(path) }
+      end
+    end
+  end
+end

data/lib/solid_objects/web/statistics.rb

@@ -0,0 +1,78 @@
+# rbs_inline: enabled
+
+module SolidObjects
+  class Web
+    # The counts behind the dashboard and behind `GET /stats`. Both read the
+    # same object, so the polled JSON and the rendered page can never disagree
+    # about what a number means.
+    class Statistics
+      EFFECT_STATUSES = %w[pending processing completed dead].freeze
+      BROADCAST_STATUSES = %w[pending processing delivered dead].freeze
+      REMINDER_STATUSES = %w[scheduled paused completed].freeze
+      PROCESS_STATES = %w[running draining stopped].freeze
+
+      # @rbs @now: Time
+
+      attr_reader :now
+
+      # @rbs (?now: Time) -> void
+      def initialize(now: SolidObjects.database_adapter.database_now)
+        @now = now
+      end
+
+      # @rbs () -> Hash[Symbol, untyped]
+      def to_h
+        {
+          instances:,
+          mailbox:,
+          effects: grouped(Effect, :status, EFFECT_STATUSES),
+          broadcasts: grouped(Broadcast, :status, BROADCAST_STATUSES),
+          reminders:,
+          dead_letters: { total: DeadLetter.count },
+          processes: grouped(Process, :shutdown_state, PROCESS_STATES),
+          server_time: now.utc.iso8601
+        }
+      end
+
+      # @rbs () -> Hash[Symbol, Integer]
+      def instances
+        {
+          total: Instance.count,
+          paused: Instance.where.not(paused_at: nil).count,
+          activated: Instance.where(activation_expires_at: now..).count
+        }
+      end
+
+      # The oldest ready message that is already due is the queue latency of
+      # this runtime: how far behind the workers are, in seconds.
+      # @rbs () -> Hash[Symbol, untyped]
+      def mailbox
+        due = ReadyMessage.where(available_at: ..now)
+        oldest = due.minimum(:available_at)
+        {
+          ready: ReadyMessage.count,
+          due: due.count,
+          claimed: ClaimedMessage.count,
+          latency: oldest ? (now - oldest).round(3) : 0.0
+        }
+      end
+
+      # @rbs () -> Hash[Symbol, Integer]
+      def reminders
+        grouped(Reminder, :status, REMINDER_STATUSES).merge(
+          due: Reminder.where(status: "scheduled", next_run_at: ..now).count
+        )
+      end
+
+      private
+
+      # A status the schema allows but the table does not currently hold still
+      # reports zero, so a row of counts keeps the same shape between polls.
+      # @rbs (untyped, Symbol, Array[String]) -> Hash[Symbol, Integer]
+      def grouped(model, column, statuses)
+        counts = model.group(column).count
+        statuses.to_h { |status| [ status.to_sym, counts.fetch(status, 0) ] }
+      end
+    end
+  end
+end

data/lib/solid_objects/web.rb

@@ -0,0 +1,222 @@
+# rbs_inline: enabled
+
+require "erb"
+require "json"
+require "securerandom"
+require "uri"
+require "rack"
+require "rack/builder"
+require "rack/static"
+
+require "solid_objects"
+require "solid_objects/web/route"
+require "solid_objects/web/router"
+require "solid_objects/web/statistics"
+require "solid_objects/web/paginator"
+require "solid_objects/web/helpers"
+require "solid_objects/web/action"
+require "solid_objects/web/csrf_protection"
+require "solid_objects/web/application"
+
+module SolidObjects
+  # An operator dashboard for the actor runtime, served as a Rack application:
+  #
+  #   Rails.application.routes.draw do
+  #     mount SolidObjects::Web => "/solid_objects"
+  #   end
+  #
+  # It is deliberately not loaded by `require "solid_objects"`. A worker
+  # process must not carry a web stack, and an application that never mounts
+  # the dashboard must not pay for it.
+  #
+  # Every page asks `configuration.authorize_administration` first. That block
+  # denies by default, so a mount alone exposes nothing until an application
+  # states who may read it.
+  class Web
+    ROOT = File.expand_path("../../web", __dir__)
+    VIEWS = File.join(ROOT, "views")
+    ASSETS = File.join(ROOT, "assets")
+
+    NONCE_KEY = "solid_objects.content_security_policy_nonce"
+    CSRF_TOKEN_KEY = "solid_objects.csrf_token"
+    NONCE_BYTES = 16
+    ASSET_CACHE_SECONDS = 86_400
+    TEMPLATE_NAME = /\A_?[a-z][a-z0-9_]*\z/
+
+    # The dashboard charts need a charting library, and this one is fetched
+    # from a public CDN with a subresource integrity hash, so a compromised CDN
+    # cannot substitute other code. A deployment with no outbound network
+    # access should vendor the file and point `chart_library_url` at it, or set
+    # that to nil to render the dashboard without charts.
+    CHART_LIBRARY_URL = "https://cdn.jsdelivr.net/npm/chart.js@4.5.0/dist/chart.umd.min.js"
+    CHART_LIBRARY_INTEGRITY = "sha384-XcdcwHqIPULERb2yDEM4R0XaQKU3YnDsrTmjACBZyfdVVqjh6xQ4/DCMd7XLcA6Y"
+
+    DEFAULT_TABS = {
+      "Dashboard" => "/",
+      "Instances" => "/instances",
+      "Mailbox" => "/mailbox",
+      "Reminders" => "/reminders",
+      "Effects" => "/effects",
+      "Broadcasts" => "/broadcasts",
+      "Dead letters" => "/dead_letters",
+      "Processes" => "/processes"
+    }.freeze
+
+    LOCK = Mutex.new
+
+    class << self
+      # A path below the mount serves a vendored copy; an absolute URL is
+      # fetched from that host and is named in the content security policy.
+      # nil renders the dashboard without charts.
+      # @rbs @chart_library_url: String?
+      # @rbs @chart_library_integrity: String?
+      attr_writer :chart_library_url, :chart_library_integrity
+
+      # @rbs () -> String?
+      def chart_library_url
+        defined?(@chart_library_url) ? @chart_library_url : CHART_LIBRARY_URL
+      end
+
+      # @rbs () -> String?
+      def chart_library_integrity
+        defined?(@chart_library_integrity) ? @chart_library_integrity : CHART_LIBRARY_INTEGRITY
+      end
+
+      # @rbs () -> bool
+      def charts?
+        !chart_library_url.nil?
+      end
+
+      # The origin the content security policy has to allow. A vendored copy
+      # served from the mount has none, so the policy stays at 'self'.
+      # @rbs () -> String?
+      def chart_library_origin
+        url = chart_library_url
+        return nil unless url&.include?("//")
+
+        uri = URI.parse(url)
+        return nil unless uri.scheme && uri.host
+
+        "#{uri.scheme}://#{uri.host}"
+      rescue URI::InvalidURIError
+        nil
+      end
+
+      # @rbs () -> Hash[String, String]
+      def tabs
+        @tabs ||= DEFAULT_TABS.dup
+      end
+
+      # Searched in order, so an extension directory added first wins over the
+      # packaged one and an application can replace a single page.
+      # @rbs () -> Array[String]
+      def views
+        @views ||= [ VIEWS ]
+      end
+
+      # @rbs () -> Array[[Array[untyped], Proc?]]
+      def middlewares
+        @middlewares ||= []
+      end
+
+      # The built stack is memoized, so a middleware added after the first
+      # request would otherwise be dropped without a word.
+      # @rbs (*untyped) ?{ () -> untyped } -> void
+      def use(*arguments, &block)
+        middlewares << [ arguments, block ]
+        LOCK.synchronize { @application = nil }
+      end
+
+      # Adds pages to the dashboard. The extension receives the application
+      # class and declares its own routes on it, which means its routes carry
+      # an authorization policy like every other route.
+      #
+      # @rbs (untyped, tab: String, path: String, ?views: String?) -> void
+      def register(extension, tab:, path:, views: nil)
+        if views
+          self.views.unshift(views)
+          # A template compiled before this call resolved against the old
+          # search path, so a replacement view would never be reached.
+          LOCK.synchronize { @templates = {} }
+        end
+        tabs[tab] = path
+        extension.registered(Application)
+      end
+
+      # @rbs (Symbol) -> untyped
+      def template(name)
+        LOCK.synchronize do
+          templates[name] ||= ERB.new(File.read(template_path(name)), trim_mode: "-")
+        end
+      end
+
+      # @rbs () -> void
+      def reset!
+        LOCK.synchronize { @templates = {} }
+        @tabs = nil
+        @views = nil
+        @middlewares = nil
+        @application = nil
+        remove_instance_variable(:@chart_library_url) if defined?(@chart_library_url)
+        remove_instance_variable(:@chart_library_integrity) if defined?(@chart_library_integrity)
+      end
+
+      # @rbs (Hash[String, untyped]) -> Array[untyped]
+      def call(env)
+        application.call(env)
+      end
+
+      # @rbs () -> Web
+      def application
+        LOCK.synchronize { @application ||= new }
+      end
+
+      private
+
+      # @rbs () -> Hash[Symbol, untyped]
+      def templates
+        @templates ||= {}
+      end
+
+      # A template name never comes from a request, and this keeps it that way
+      # rather than trusting every future caller to know it.
+      # @rbs (Symbol) -> String
+      def template_path(name)
+        raise ArgumentError, "invalid template name" unless name.to_s.match?(TEMPLATE_NAME)
+
+        found = views.lazy.map { |directory| File.join(directory, "#{name}.erb") }.find { |path| File.exist?(path) }
+        found || raise(ArgumentError, "no template named #{name}")
+      end
+    end
+
+    # @rbs (Hash[String, untyped]) -> Array[untyped]
+    def call(env)
+      env[NONCE_KEY] = SecureRandom.base64(NONCE_BYTES)
+      app.call(env)
+    end
+
+    # @rbs () -> untyped
+    def app
+      @app ||= build
+    end
+
+    private
+
+    # @rbs () -> untyped
+    def build
+      assets = ASSETS
+      extra = self.class.middlewares
+
+      ::Rack::Builder.new do
+        use ::Rack::Static,
+          urls: [ "/stylesheets", "/javascripts" ],
+          root: assets,
+          cascade: true,
+          header_rules: [ [ :all, { "cache-control" => "private, max-age=#{ASSET_CACHE_SECONDS}" } ] ]
+        extra.each { |arguments, block| use(*arguments, &block) }
+        use CsrfProtection
+        run Application.new
+      end
+    end
+  end
+end

data/sig/generated/lib/solid_objects/actor.rbs

@@ -87,8 +87,8 @@ module SolidObjects
     # @rbs (Symbol | String) { (*untyped, **untyped) -> untyped } -> ActorDefinition::Handler
     def self.query: (Symbol | String) { (*untyped, **untyped) -> untyped } -> ActorDefinition::Handler
 
-    # @rbs (Symbol | String) ?{ () -> untyped } -> ActorDefinition::Handler
-    def self.observable: (Symbol | String) ?{ () -> untyped } -> ActorDefinition::Handler
+    # @rbs (Symbol | String, ?broadcast: Symbol) ?{ () -> untyped } -> ActorDefinition::Handler
+    def self.observable: (Symbol | String, ?broadcast: Symbol) ?{ () -> untyped } -> ActorDefinition::Handler
 
     # @rbs (Symbol | String) { (untyped, untyped) -> untyped } -> ActorDefinition::Handler
     def self.broadcast_payload: (Symbol | String) { (untyped, untyped) -> untyped } -> ActorDefinition::Handler

data/sig/generated/lib/solid_objects/actor_definition.rbs

@@ -44,6 +44,8 @@ module SolidObjects
 
     @payload_broadcasts: Hash[Symbol, Handler]
 
+    @observable_broadcasts: Hash[Symbol, Symbol]
+
     @observables: Hash[Symbol, Handler]
 
     @queries: Hash[Symbol, Handler]
@@ -82,8 +84,11 @@ module SolidObjects
     # @rbs (Symbol | String, Proc) -> Handler
     def add_query: (Symbol | String, Proc) -> Handler
 
-    # @rbs (Symbol | String, Proc?) -> Handler
-    def add_observable: (Symbol | String, Proc?) -> Handler
+    # @rbs (Symbol | String, Proc?, broadcast: Symbol) -> Handler
+    def add_observable: (Symbol | String, Proc?, broadcast: Symbol) -> Handler
+
+    # @rbs (Symbol | String) -> bool
+    def broadcasts_observable_value?: (Symbol | String) -> bool
 
     # @rbs (Symbol | String, Proc) -> Handler
     def add_payload_broadcast: (Symbol | String, Proc) -> Handler
@@ -109,6 +114,8 @@ module SolidObjects
 
     attr_reader method_messages: untyped
 
+    attr_reader observable_broadcasts: untyped
+
     # @rbs (Symbol) -> Handler
     def add_method_message: (Symbol) -> Handler
 

data/sig/generated/lib/solid_objects/errors.rbs

@@ -179,6 +179,9 @@ module SolidObjects
   class UnknownCommitAction < NonRetryableError
   end
 
+  class InvalidRejectionCode < NonRetryableError
+  end
+
   class Rejected < Error
     @code: String
 

data/sig/generated/lib/solid_objects/reminder_scheduler.rbs

@@ -13,8 +13,8 @@ module SolidObjects
     # @rbs (?process_registry: ProcessRegistry, ?database_adapter: DatabaseAdapter) -> void
     def initialize: (?process_registry: ProcessRegistry, ?database_adapter: DatabaseAdapter) -> void
 
-    # @rbs () -> bool
-    def run_once: () -> bool
+    # @rbs (?now: Time?) -> bool
+    def run_once: (?now: Time?) -> bool
 
     # @rbs () -> void
     def stop: () -> void
@@ -37,11 +37,11 @@ module SolidObjects
 
     attr_reader database_adapter: untyped
 
-    # @rbs () -> Reminder?
-    def claim_next: () -> Reminder?
+    # @rbs (now: Time?) -> Reminder?
+    def claim_next: (now: Time?) -> Reminder?
 
-    # @rbs (Reminder) -> MessageReference?
-    def enqueue: (Reminder) -> MessageReference?
+    # @rbs (Reminder, now: Time?) -> MessageReference?
+    def enqueue: (Reminder, now: Time?) -> MessageReference?
 
     # @rbs (Reminder) -> void
     def release: (Reminder) -> void
@@ -51,5 +51,8 @@ module SolidObjects
 
     # @rbs (Reminder, Time) -> Time
     def next_run_at: (Reminder, Time) -> Time
+
+    # @rbs (Time?) -> Time?
+    def normalize_test_time: (Time?) -> Time?
   end
 end

data/sig/generated/lib/solid_objects/test_helper.rbs

@@ -26,6 +26,9 @@ module SolidObjects
     # @rbs (?roles: Array[Symbol], ?max_passes: Integer) -> Integer
     def drain_solid_objects: (?roles: Array[Symbol], ?max_passes: Integer) -> Integer
 
+    # @rbs (now: Time, ?max_reminders: Integer) -> Integer
+    def run_due_reminders: (now: Time, ?max_reminders: Integer) -> Integer
+
     private
 
     # @rbs (Array[Symbol]) -> Array[Worker | EffectExecutor | ReminderScheduler | BroadcastExecutor]

data/sig/generated/lib/solid_objects/web/action.rbs

@@ -0,0 +1,78 @@
+# Generated from lib/solid_objects/web/action.rb with RBS::Inline
+
+module SolidObjects
+  class Web
+    # One request. A route handler runs inside an instance of this class, so a
+    # handler and the template it renders share the same helpers and the same
+    # request.
+    class Action
+      include Helpers
+
+      @response_status: Integer
+
+      @layout_rendered: bool
+
+      @request: untyped
+
+      @captures: Hash[Symbol, String?]
+
+      @route: Route
+
+      @env: Hash[String, untyped]
+
+      attr_reader env: untyped
+
+      attr_reader route: untyped
+
+      attr_reader response_status: untyped
+
+      # @rbs (env: Hash[String, untyped], route: Route) -> void
+      def initialize: (env: Hash[String, untyped], route: Route) -> void
+
+      # Sets the status a rendered page is served with. `halt` and `redirect`
+      # stop the handler, so a page that must render its own body and still
+      # report a failure needs this instead.
+      # @rbs (Integer) -> void
+      def status: (Integer) -> void
+
+      # @rbs () -> untyped
+      def request: () -> untyped
+
+      # @rbs () -> Hash[untyped, untyped]?
+      def session: () -> Hash[untyped, untyped]?
+
+      # @rbs (Symbol) -> String?
+      def route_params: (Symbol) -> String?
+
+      # @rbs (String) -> untyped
+      def url_params: (String) -> untyped
+
+      # @rbs () -> untyped
+      def call: () -> untyped
+
+      # The layout is rendered once per request. The flag is raised before the
+      # page body runs so a partial the body renders returns its own fragment
+      # rather than a second whole page. The layout reads the page it wraps
+      # from `locals.fetch(:content)`.
+      # @rbs (Symbol, ?Hash[Symbol, untyped]) -> String
+      def erb: (Symbol, ?Hash[Symbol, untyped]) -> String
+
+      # @rbs (Integer, ?String) -> void
+      def halt: (Integer, ?String) -> void
+
+      # @rbs (String) -> void
+      def redirect: (String) -> void
+
+      # @rbs (untyped) -> void
+      def json: (untyped) -> void
+
+      private
+
+      # `locals` is a local variable of this method, so a template reads it by
+      # name, and every helper is reachable because the template runs against
+      # this object.
+      # @rbs (untyped, Hash[Symbol, untyped]) -> String
+      def evaluate: (untyped, Hash[Symbol, untyped]) -> String
+    end
+  end
+end

data/sig/generated/lib/solid_objects/web/application.rbs

@@ -0,0 +1,50 @@
+# Generated from lib/solid_objects/web/application.rb with RBS::Inline
+
+module SolidObjects
+  class Web
+    # The pages. Each route states the administration policy it needs, and
+    # `call` asks that policy before the handler runs, so a page cannot read
+    # the actor tables on behalf of an unauthorized request.
+    class Application
+      extend Router
+
+      SCRIPT_PLACEHOLDER: ::String
+
+      CONTENT_SECURITY_POLICY: untyped
+
+      MAILBOX_MEMBERSHIPS: untyped
+
+      RECENT_LIMIT: ::Integer
+
+      CHART_TYPE_LIMIT: ::Integer
+
+      # @rbs (Hash[String, untyped]) -> Array[untyped]
+      def call: (Hash[String, untyped]) -> Array[untyped]
+
+      private
+
+      # @rbs (Action, untyped) -> Array[untyped]
+      def respond: (Action, untyped) -> Array[untyped]
+
+      # @rbs (Action) -> bool
+      def authorized?: (Action) -> bool
+
+      # @rbs (Hash[String, untyped]) -> Hash[String, String]
+      def page_headers: (Hash[String, untyped]) -> Hash[String, String]
+
+      # The chart host is named only when one is configured, so a deployment
+      # that vendors the library or turns charts off never advertises a third
+      # party origin it does not use.
+      # @rbs (Hash[String, untyped]) -> String
+      def content_security_policy: (Hash[String, untyped]) -> String
+
+      # The cascade header lets a host application serve its own 404 for a path
+      # below the mount that the dashboard does not define.
+      # @rbs () -> Array[untyped]
+      def not_found: () -> Array[untyped]
+
+      # @rbs () -> Array[untyped]
+      def forbidden: () -> Array[untyped]
+    end
+  end
+end

data/sig/generated/lib/solid_objects/web/csrf_protection.rbs

@@ -0,0 +1,55 @@
+# Generated from lib/solid_objects/web/csrf_protection.rb with RBS::Inline
+
+module SolidObjects
+  class Web
+    # A state changing request must carry the token of the session that asked
+    # for the form. The token a form receives is masked with a fresh one-time
+    # pad on every request, so the bytes on the wire differ each time and a
+    # compression side channel cannot recover the session token.
+    class CsrfProtection
+      SAFE_METHODS: untyped
+
+      TOKEN_BYTES: ::Integer
+
+      MISSING_SESSION: ::String
+
+      # @rbs (untyped) -> void
+      def initialize: (untyped) -> void
+
+      # @rbs (Hash[String, untyped]) -> Array[untyped]
+      def call: (Hash[String, untyped]) -> Array[untyped]
+
+      private
+
+      # @rbs (Hash[String, untyped]) -> bool
+      def accept?: (Hash[String, untyped]) -> bool
+
+      # @rbs (Hash[String, untyped], String?) -> bool
+      def valid?: (Hash[String, untyped], String?) -> bool
+
+      # @rbs (String, String) -> bool
+      def matches?: (String, String) -> bool
+
+      # @rbs (String) -> String
+      def mask: (String) -> String
+
+      # @rbs (String) -> String
+      def unmask: (String) -> String
+
+      # @rbs (String, String) -> String
+      def exclusive_or: (String, String) -> String
+
+      # @rbs (String) -> String
+      def encode: (String) -> String
+
+      # @rbs (String) -> String?
+      def decode: (String) -> String?
+
+      # @rbs (Hash[String, untyped]) -> Hash[untyped, untyped]
+      def session!: (Hash[String, untyped]) -> Hash[untyped, untyped]
+
+      # @rbs () -> Array[untyped]
+      def forbidden: () -> Array[untyped]
+    end
+  end
+end