exekutor 0.1.0 → 0.1.1

data/lib/exekutor/internal/provider.rb

@@ -8,16 +8,18 @@ module Exekutor
   module Internal
     # Reserves jobs and provides them to an executor
     class Provider
-      include Executable, Callbacks, Logger
+      include Logger
+      include Callbacks
+      include Executable
 
       define_callbacks :on_queue_empty, freeze: true
 
       # Represents an unknown value
       UNKNOWN = Object.new.freeze
-      private_constant "UNKNOWN"
+      private_constant :UNKNOWN
 
       MAX_WAIT_TIMEOUT = 300
-      private_constant "MAX_WAIT_TIMEOUT"
+      private_constant :MAX_WAIT_TIMEOUT
 
       # Creates a new provider
       # @param reserver [Reserver] the job reserver
@@ -48,14 +50,14 @@ module Exekutor
 
         # Always poll at startup to fill up threads, use small jitter so workers started at the same time dont hit
         # the db at the same time
-        @next_poll_at.set (1 + 2 * Kernel.rand).second.from_now
+        @next_poll_at.set (1 + (2 * Kernel.rand)).seconds.from_now.to_f
         start_thread
         true
       end
 
       # Stops the provider
       def stop
-        set_state :stopped
+        self.state = :stopped
         @event.set
       end
 
@@ -63,7 +65,7 @@ module Exekutor
       def poll
         raise Exekutor::Error, "Provider is not running" unless running?
 
-        @next_poll_at.set Time.now
+        @next_poll_at.set Time.now.to_f
         @event.set
       end
 
@@ -71,51 +73,39 @@ module Exekutor
       # argument is given. Updates the timestamp for the earliest job is a timestamp is given and that timestamp is
       # before the known timestamp. Does nothing if a timestamp is given and the earliest job timestamp is not known.
       # @param scheduled_at [Time,Numeric] the time a job is scheduled at
-      # @return [Time] the timestamp for the next job, or +nil+ if the timestamp is unknown or no jobs are pending
+      # @return [Float,nil] the timestamp for the next job, or +nil+ if the timestamp is unknown or no jobs are pending
       def update_earliest_scheduled_at(scheduled_at = UNKNOWN)
-        overwrite_unknown = false
-        case scheduled_at
-        when UNKNOWN
-          # If we fetch the value from the DB, we can safely overwrite the UNKNOWN value
-          overwrite_unknown = true
-          scheduled_at = @reserver.earliest_scheduled_at
-        when Numeric
-          scheduled_at = Time.at(scheduled_at)
-        when Time
-          #  All good
-        else
+        scheduled_at = scheduled_at.to_f if scheduled_at.is_a? Time
+        unless scheduled_at == UNKNOWN || scheduled_at.is_a?(Numeric)
           raise ArgumentError, "scheduled_at must be a Time or Numeric"
         end
 
-        updated = false
-        scheduled_at = @next_job_scheduled_at.update do |current|
-          if current == UNKNOWN
-            if overwrite_unknown || scheduled_at <= Time.now
-              updated = true
-              scheduled_at
-            else
-              current
-            end
-          elsif current.nil? || scheduled_at.nil? || current > scheduled_at
-            updated = true
-            scheduled_at
-          else
-            current
-          end
+        changed = false
+        earliest_scheduled_at = @next_job_scheduled_at.update do |current|
+          earliest = ScheduledAtComparer.determine_earliest(current, scheduled_at, @reserver)
+          changed = earliest != current
+          earliest
         end
-        if scheduled_at == UNKNOWN
+
+        if earliest_scheduled_at == UNKNOWN
           nil
         else
-          @event.set if updated && scheduled_at.present?
-          scheduled_at
+          @event.set if changed && earliest_scheduled_at.present?
+          earliest_scheduled_at
         end
       end
 
       private
 
       # Starts the provision thread
-      def start_thread
-        @pool.post(&method(:run)) if running?
+      def start_thread(delay: nil)
+        return unless running?
+
+        if delay
+          Concurrent::ScheduledTask.execute(delay, executor: @pool) { run }
+        else
+          @pool.post { run }
+        end
       end
 
       # Does the provisioning of jobs to the executor. Blocks until the provider is stopped.
@@ -134,19 +124,24 @@ module Exekutor
             consecutive_errors.value = 0
           end
         end
-      rescue StandardError => err
-        Exekutor.on_fatal_error err, "[Provider] Runtime error!"
-        consecutive_errors.increment
-        if running?
-          delay = restart_delay
-          logger.info "Restarting in %0.1f seconds…" % [delay]
-          Concurrent::ScheduledTask.execute(delay, executor: @pool, &method(:run))
-        end
+      rescue StandardError => e
+        on_thread_error(e)
       ensure
         BaseRecord.connection_pool.release_connection
         @thread_running.make_false
       end
 
+      # Called when an error is raised in #run
+      def on_thread_error(error)
+        Exekutor.on_fatal_error error, "[Provider] Runtime error!"
+        return unless running?
+
+        consecutive_errors.increment
+        delay = restart_delay
+        logger.info format("Restarting in %0.1f seconds…", delay)
+        start_thread delay: delay
+      end
+
       # Waits for any event to happen. An event could be:
       # - The listener was notified of a new job;
       # - The next job is scheduled for the current time;
@@ -157,8 +152,8 @@ module Exekutor
         return unless timeout.positive?
 
         @event.wait timeout
-      rescue StandardError => err
-        Exekutor.on_fatal_error err, "[Provider] An error occurred while waiting"
+      rescue StandardError => e
+        Exekutor.on_fatal_error e, "[Provider] An error occurred while waiting"
         sleep 0.1 if running?
       ensure
         throw :shutdown unless running?
@@ -171,21 +166,8 @@ module Exekutor
         return unless available_workers.positive?
 
         jobs = @reserver.reserve available_workers
-        unless jobs.nil?
-          begin
-            logger.debug "Reserved #{jobs.size} job(s)"
-            jobs.each(&@executor.method(:post))
-          rescue Exception # rubocop:disable Lint/RescueException
-            # Try to release all jobs before re-raising
-            begin
-              Exekutor::Job.where(id: jobs.collect { |job| job[:id] }, status: "e")
-                           .update_all(status: "p", worker_id: nil)
-            rescue # rubocop:disable Lint/RescueStandardError
-              # ignored
-            end
-            raise
-          end
-        end
+        execute_jobs jobs unless jobs.nil?
+
         if jobs.nil? || jobs.size.to_i < available_workers
           # If we ran out of work, update the earliest scheduled at
           update_earliest_scheduled_at
@@ -194,8 +176,24 @@ module Exekutor
 
         elsif @next_job_scheduled_at.get == UNKNOWN
           # If the next job timestamp is still unknown, set it to now to indicate there's still work to do
-          @next_job_scheduled_at.set Time.now
+          @next_job_scheduled_at.set Time.now.to_f
+        end
+      end
+
+      # Posts the given jobs to the executor thread pool
+      # @param jobs [Array] the jobs to execute
+      def execute_jobs(jobs)
+        logger.debug "Reserved #{jobs.size} job(s)"
+        jobs.each { |job| @executor.post(job) }
+      rescue Exception # rubocop:disable Lint/RescueException
+        # Try to release all jobs before re-raising
+        begin
+          Exekutor::Job.where(id: jobs.pluck(:id), status: "e")
+                       .update_all(status: "p", worker_id: nil)
+        rescue StandardError
+          # ignored
         end
+        raise
       end
 
       def perform_pending_job_updates
@@ -224,7 +222,7 @@ module Exekutor
         return if jobs&.size.to_i.zero?
 
         logger.info "Restarting #{jobs.size} abandoned job#{"s" if jobs.size > 1}"
-        jobs.each(&@executor.method(:post))
+        jobs.each { |job| @executor.post(job) }
       end
 
       # @return [Boolean] Whether the polling is enabled. Ie. whether a polling interval is set.
@@ -232,7 +230,7 @@ module Exekutor
         @polling_interval.present?
       end
 
-      # @return [Time,nil] the 'scheduled at' value for the next job, or nil if unknown or if there is no pending job
+      # @return [Float,nil] the 'scheduled at' value for the next job, or nil if unknown or if there is no pending job
       def next_job_scheduled_at
         at = @next_job_scheduled_at.get
         if at == UNKNOWN
@@ -243,10 +241,10 @@ module Exekutor
         end
       end
 
-      # @return [Time,nil] When the next poll is scheduled, or nil if polling is disabled
+      # @return [Float,nil] When the next poll is scheduled, or nil if polling is disabled
       def next_poll_scheduled_at
         if polling_enabled?
-          @next_poll_at.update { |planned_at| planned_at || Time.now + polling_interval }
+          @next_poll_at.update { |planned_at| planned_at || (Time.now.to_f + polling_interval) }
         else
           # noinspection RubyMismatchedReturnType
           @next_poll_at.get
@@ -262,9 +260,9 @@ module Exekutor
 
         timeout = [MAX_WAIT_TIMEOUT].tap do |timeouts|
           # noinspection RubyMismatchedArgumentType
-          timeouts.append next_job_at - Time.now if next_job_at
+          timeouts.append next_job_at - Time.now.to_f if next_job_at
           # noinspection RubyMismatchedArgumentType
-          timeouts.append next_poll_at - Time.now if next_poll_at
+          timeouts.append next_poll_at - Time.now.to_f if next_poll_at
         end.min
 
         if timeout <= 0.001
@@ -278,13 +276,13 @@ module Exekutor
       # @return [Boolean] Whether the `reserver` should be called.
       def reserve_jobs_now?
         next_poll_at = next_poll_scheduled_at
-        if next_poll_at && next_poll_at - Time.now <= 0.001
-          @next_poll_at.update { Time.now + polling_interval if polling_enabled? }
+        if next_poll_at && next_poll_at - Time.now.to_f <= 0.001
+          @next_poll_at.update { Time.now.to_f + polling_interval if polling_enabled? }
           return true
         end
 
         next_job_at = next_job_scheduled_at
-        next_job_at && next_job_at <= Time.now
+        next_job_at && next_job_at <= Time.now.to_f
       end
 
       # @return [Float] Gets the polling interval jitter
@@ -295,7 +293,7 @@ module Exekutor
       # Get the polling interval. If a jitter is configured, the interval is reduced or increased by `0.5 * jitter`.
       # @return [Float] The amount of seconds before the next poll
       def polling_interval
-        raise "Polling is disabled" unless @polling_interval.present?
+        raise "Polling is disabled" if @polling_interval.blank?
 
         @polling_interval + if polling_interval_jitter.zero?
                               0
@@ -303,6 +301,27 @@ module Exekutor
                               (Kernel.rand - 0.5) * polling_interval_jitter
                             end
       end
+
+      # Abstraction to determine earliest out of 2 scheduled at timestamps
+      class ScheduledAtComparer
+        def self.determine_earliest(current_value, other_value, reserver)
+          if other_value == UNKNOWN
+            # Fetch the value from the db
+            reserver.earliest_scheduled_at&.to_f
+          elsif current_value == UNKNOWN
+            # We don't know the value yet, don't use the given value as earliest unless work is scheduled immediately
+            other_value > Time.now.to_f ? UNKNOWN : other_value
+          elsif current_value.nil? || current_value > other_value
+            # The given value is earlier than the known value
+            other_value
+          else
+            # No changes
+            current_value
+          end
+        end
+      end
+
+      private_constant :ScheduledAtComparer
     end
   end
 end

data/lib/exekutor/internal/reserver.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Exekutor
   # @private
   module Internal
@@ -18,7 +19,7 @@ module Exekutor
 
       # Reserves pending jobs
       # @param limit [Integer] the number of jobs to reserve
-      # @return [Array<Job>,nil] the reserved jobs, or nil if no jobs were reserved
+      # @return [Array<Hash>,nil] the reserved jobs, or nil if no jobs were reserved
       def reserve(limit)
         return unless limit.positive?
 
@@ -36,6 +37,9 @@ module Exekutor
         parse_jobs results
       end
 
+      # Gets the jobs that are assigned to this worker and have an id that is not included in +active_job_ids+
+      # @param active_job_ids [Array<String>] The ids of the jobs that should be excluded
+      # @return [Array<Hash>] the jobs
       def get_abandoned_jobs(active_job_ids)
         jobs = Exekutor::Job.executing.where(worker_id: @worker_id)
         jobs = jobs.where.not(id: active_job_ids) if active_job_ids.present?
@@ -59,7 +63,7 @@ module Exekutor
           { id: result["id"],
             payload: parse_json(result["payload"]),
             options: parse_json(result["options"]),
-            scheduled_at: result['scheduled_at'] }
+            scheduled_at: result["scheduled_at"] }
         end
       end
 
@@ -71,25 +75,36 @@ module Exekutor
       # Builds SQL filter for the given queues
       def build_queue_filter_sql(queues)
         return nil if queues.nil? || (queues.is_a?(Array) && queues.empty?)
-        unless queues.is_a?(String) || queues.is_a?(Symbol) || queues.is_a?(Array)
-          raise ArgumentError, "queues must be nil, a String, Symbol, or an array of Strings or Symbols"
-        end
 
         queues = queues.first if queues.is_a?(Array) && queues.one?
-        if queues.is_a? Array
-          unless queues.all? { |q| (q.is_a?(String) || q.is_a?(Symbol)) && !q.blank? }
-            raise ArgumentError, "queues contains an invalid value"
-          end
+        validate_queues! queues
 
+        if queues.is_a? Array
           Exekutor::Job.sanitize_sql_for_conditions(["AND queue IN (?)", queues])
         else
-          raise ArgumentError, "queue name cannot be empty" if queues.blank?
-
           Exekutor::Job.sanitize_sql_for_conditions(["AND queue = ?", queues])
         end
       end
 
+      # Raises an error if the queues value is invalid
+      # @param queues [String,Symbol,Array<String,Symbol>] the queues to validate
+      # @raise [ArgumentError] if the queue is invalid or includes an invalid value
+      def validate_queues!(queues)
+        case queues
+        when Array
+          raise ArgumentError, "queues contains an invalid value" unless queues.all? { |queue| valid_queue_name? queue }
+        when String, Symbol
+          raise ArgumentError, "queue name cannot be empty" unless valid_queue_name? queues
+        else
+          raise ArgumentError, "queues must be nil, a String, Symbol, or an array of Strings or Symbols"
+        end
+      end
+
+      # @param queue [String,Symbol] the name of a queue
+      # @return [Boolean] whether the name is a valid queue name
+      def valid_queue_name?(queue)
+        (queue.is_a?(String) || queue.is_a?(Symbol)) && queue.present? && queue.length <= Queue::MAX_NAME_LENGTH
+      end
     end
   end
 end
-

data/lib/exekutor/internal/status_server.rb

@@ -1,7 +1,22 @@
 # frozen_string_literal: true
+
 module Exekutor
   module Internal
-    # Serves a simple health check app
+    # Serves a simple health check app. The app provides 4 endpoints:
+    # - +/+, which lists the other endpoints;
+    # - +/ready+, which indicates whether the worker is ready to start work;
+    # - +/live+, which indicates whether the worker is ready and whether the worker is still alive;
+    # - +/threads+, which indicated the thread usage of the worker.
+    #
+    # Please note that this server uses +webrick+ by default, which is no longer a default gem from ruby 3.0 onwards.
+    #
+    # === Example requests
+    #    $ curl localhost:9000/ready
+    #    [OK] ID: f1a2ee6a-cdac-459c-a4b8-de7c6a8bbae6; State: started
+    #    $ curl localhost:9000/live
+    #    [OK] ID: f1a2ee6a-cdac-459c-a4b8-de7c6a8bbae6; State: started; Heartbeat: 2023-04-05T16:27:00Z
+    #    $ curl localhost:9000/threads
+    #    {"minimum":1,"maximum":10,"available":4,"usage_percent":60.0}
     class StatusServer
       include Internal::Logger
       include Internal::Executable
@@ -19,24 +34,27 @@ module Exekutor
         @server = Concurrent::AtomicReference.new
       end
 
+      # Starts the web server
       def start
         return false unless compare_and_set_state :pending, :started
 
         start_thread
       end
 
+      # @return [Boolean] whether the web server is active
       def running?
         super && @thread_running.value
       end
 
+      # Stops the web server
       def stop
-        set_state :stopped
+        self.state = :stopped
         return unless @thread_running.value
 
         server = @server.value
-        if server&.respond_to? :shutdown
+        if server.respond_to? :shutdown
           server.shutdown
-        elsif server&.respond_to? :stop
+        elsif server.respond_to? :stop
           server.stop
         elsif server
           Exekutor.say! "Cannot shutdown status server, #{server.class.name} does not respond to shutdown or stop"
@@ -45,6 +63,7 @@ module Exekutor
 
       protected
 
+      # Runs the web server, should be called from a separate thread
       def run(worker, port)
         return unless state == :started && @thread_running.make_true
 
@@ -53,11 +72,11 @@ module Exekutor
                      Logger: ::Logger.new(File.open(File::NULL, "w")), AccessLog: []) do |server|
           @server.set server
         end
-      rescue StandardError => err
-        Exekutor.on_fatal_error err, "[HealthServer] Runtime error!"
+      rescue StandardError => e
+        Exekutor.on_fatal_error e, "[Status server] Runtime error!"
         if running?
           logger.info "Restarting in 10 seconds…"
-          Concurrent::ScheduledTask.execute(10.0, executor: @pool, &method(:start_thread))
+          Concurrent::ScheduledTask.execute(10.0, executor: @pool) { start_thread }
         end
       ensure
         @thread_running.make_false
@@ -65,68 +84,81 @@ module Exekutor
 
       # The Rack-app for the health-check server
       class App
-
         def initialize(worker, heartbeat_timeout)
           @worker = worker
           @heartbeat_timeout = heartbeat_timeout
         end
 
-        def flatlined?
-          last_heartbeat = @worker.last_heartbeat
-          last_heartbeat.nil? || last_heartbeat < @heartbeat_timeout.minutes.ago
-        end
-
         def call(env)
           case Rack::Request.new(env).path
           when "/"
-            [200, {}, [
-              <<~RESPONSE
-                [Exekutor]
-                 - Use GET /ready to check whether the worker is running and connected to the DB
-                 - Use GET /live to check whether the worker is running and is not hanging
-                 - Use GET /threads to check thread usage
-              RESPONSE
-            ]]
+            render_root
           when "/ready"
-            running = @worker.running?
-            if running
-              Exekutor::Job.connection_pool.with_connection do |connection|
-                running = connection.active?
-              end
-            end
-            running = false if running && flatlined?
-            [(running ? 200 : 503), { "Content-Type" => "text/plain" }, [
-              "#{running ? "[OK]" : "[Service unavailable]"} ID: #{@worker.id}; State: #{@worker.state}"
-            ]]
+            render_ready
           when "/live"
-            running = @worker.running?
-            last_heartbeat = if running
-                               @worker.last_heartbeat
-                             end
-            if running && (last_heartbeat.nil? || last_heartbeat < @heartbeat_timeout.minutes.ago)
-              running = false
-            end
-            [(running ? 200 : 503), { "Content-Type" => "text/plain" }, [
-              "#{running ? "[OK]" : "[Service unavailable]"} ID: #{@worker.id}; State: #{@worker.state}; Heartbeat: #{last_heartbeat&.iso8601 || "null"}"
-            ]]
+            render_live
           when "/threads"
-            if @worker.running?
-              info = @worker.thread_stats
-              [(info ? 200 : 503), { "Content-Type" => "application/json" }, [info.to_json]]
-            else
-              [503, {"Content-Type" => "application/json"}, [{ error: "Worker not running" }.to_json]]
-            end
+            render_threads
           else
             [404, {}, ["Not found"]]
           end
         end
+
+        private
+
+        def flatlined?(last_heartbeat = @worker.last_heartbeat)
+          last_heartbeat.nil? || last_heartbeat < @heartbeat_timeout.minutes.ago
+        end
+
+        def render_threads
+          if @worker.running?
+            info = @worker.thread_stats
+            [(info ? 200 : 503), { "Content-Type" => "application/json" }, [info.to_json]]
+          else
+            [503, { "Content-Type" => "application/json" }, [{ error: "Worker not running" }.to_json]]
+          end
+        end
+
+        def render_live
+          running = @worker.running?
+          last_heartbeat = (@worker.last_heartbeat if running)
+          running = false if flatlined?(last_heartbeat)
+          [(running ? 200 : 503), { "Content-Type" => "text/plain" }, [
+            "#{running ? "[OK]" : "[Service unavailable]"} ID: #{@worker.id}; State: #{@worker.state}; " \
+            "Heartbeat: #{last_heartbeat&.iso8601 || "null"}"
+          ]]
+        end
+
+        def render_ready
+          running = @worker.running?
+          if running
+            Exekutor::Job.connection_pool.with_connection do |connection|
+              running = connection.active?
+            end
+          end
+          running = false if running && flatlined?
+          [(running ? 200 : 503), { "Content-Type" => "text/plain" }, [
+            "#{running ? "[OK]" : "[Service unavailable]"} ID: #{@worker.id}; State: #{@worker.state}"
+          ]]
+        end
+
+        def render_root
+          [200, {}, [
+            <<~RESPONSE
+              [Exekutor]
+               - Use GET /ready to check whether the worker is running and connected to the DB
+               - Use GET /live to check whether the worker is running and is not hanging
+               - Use GET /threads to check thread usage
+            RESPONSE
+          ]]
+        end
       end
 
       private
 
       def start_thread
-        @pool.post(@worker, @port, &method(:run)) if state == :started
+        @pool.post(@worker, @port) { |*args| run(*args) } if state == :started
       end
     end
   end
-end
+end

data/lib/exekutor/job.rb

@@ -28,4 +28,4 @@ module Exekutor
       update! status: "d"
     end
   end
-end
+end

data/lib/exekutor/job_error.rb

@@ -8,4 +8,4 @@ module Exekutor
     self.implicit_order_column = :created_at
     belongs_to :job
   end
-end
+end

data/lib/exekutor/job_options.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Exekutor
   # Mixin which defines custom job options for Exekutor. This module should be included in your job class.
   # You can define the following options after including this module:
@@ -32,7 +34,7 @@ module Exekutor
 
     # @private
     VALID_EXEKUTOR_OPTIONS = %i[queue_timeout execution_timeout].freeze
-    private_constant "VALID_EXEKUTOR_OPTIONS"
+    private_constant :VALID_EXEKUTOR_OPTIONS
 
     # @return [Hash<Symbol, Object>] the exekutor options for this job
     attr_reader :exekutor_options
@@ -67,28 +69,35 @@ module Exekutor
       end
 
       # Validates the exekutor job options passed to {#exekutor_options} and +#set+
-      # @param options [Hash<Symbol, Object>] the options to validate
+      # @param options [Hash<Symbol, Any>] the options to validate
       # @raise [InvalidOption] if any of the options are invalid
       # @private
       # @return [void]
       def validate_exekutor_options!(options)
-        return unless options.present?
+        return true if options.blank?
 
-        invalid_options = options.keys - VALID_EXEKUTOR_OPTIONS
-        if invalid_options.present?
+        if (invalid_options = options.keys - VALID_EXEKUTOR_OPTIONS).present?
           raise InvalidOption, "Invalid option#{"s" if invalid_options.many?}: " \
-            "#{invalid_options.map(&:inspect).join(", ")}. " \
-            "Valid options are: #{VALID_EXEKUTOR_OPTIONS.map(&:inspect).join(", ")}"
-        end
-        if options[:queue_timeout]
-          raise InvalidOption, ":queue_timeout must be an interval" unless options[:queue_timeout].is_a? ActiveSupport::Duration
-        end
-        if options[:execution_timeout]
-          raise InvalidOption, ":execution_timeout must be an interval" unless options[:execution_timeout].is_a? ActiveSupport::Duration
+                               "#{invalid_options.map(&:inspect).join(", ")}. " \
+                               "Valid options are: #{VALID_EXEKUTOR_OPTIONS.map(&:inspect).join(", ")}"
         end
+        JobOptions.validate_option_type! options, :queue_timeout, ::ActiveSupport::Duration
+        JobOptions.validate_option_type! options, :execution_timeout, ::ActiveSupport::Duration
+        true
       end
     end
 
+    # Validates the type of an option
+    # @param options [Hash<Symbol, Any>] the options
+    # @param name [Symbol] the name of the option to validate
+    # @param valid_type [Class] the valid type for the value
+    # @raise [InvalidOption] if the configured value is not an instance of +valid_type+
+    def self.validate_option_type!(options, name, valid_type)
+      return if options[name].nil? || options[name].is_a?(valid_type)
+
+      raise InvalidOption, ":#{name} must be an instance of #{valid_type.name} (given: #{options[name].class.name})"
+    end
+
     # Raised when invalid options are given
     class InvalidOption < ::Exekutor::Error; end
   end