temporalio 0.2.0-x86_64-darwin

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 209ea74a531b7d0259dc1708d459875aefeabf8cd514052dde31fdb5ed901072
+  data.tar.gz: '038fc31c03ba9e3d2b542ebc863c7dc85b61a477f906b615562efde503764f4f'
+SHA512:
+  metadata.gz: 0cb8f9adf5d9f0b25680abfb31aa6d1c89f46cdeb9ab30abc805461528e55c72777b49b4c2102335913d877eb1231a6db6bea97a4329a595e8e7f3753ccb70d0
+  data.tar.gz: 86a1a7a7df4391bacb975be3e42e48662c85a6fffd6e8114eeee79f02ac4638cc83be4bdb6778a7b29dcf21c64a310977f48a1e3fa308bdd8d73e392bd94d286

data/Gemfile

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+group :development do
+  gem 'activemodel'
+  gem 'activerecord'
+  gem 'async'
+  gem 'base64'
+  gem 'grpc', '>= 1.65.0.pre2'
+  gem 'grpc-tools'
+  gem 'minitest'
+  gem 'rake'
+  gem 'rake-compiler'
+  gem 'rbs', '~> 3.5.3'
+  gem 'rb_sys', '~> 0.9.63'
+  gem 'rubocop'
+  gem 'sqlite3', '~> 1.4'
+  gem 'steep', '~> 1.7.1'
+  gem 'yard'
+end

data/Rakefile

@@ -0,0 +1,387 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/BlockLength, Lint/MissingCopEnableDirective, Style/DocumentationMethod
+
+require 'bundler/gem_tasks'
+require 'rb_sys/cargo/metadata'
+require 'rb_sys/extensiontask'
+
+task build: :compile
+
+GEMSPEC = Gem::Specification.load('temporalio.gemspec')
+
+begin
+  RbSys::ExtensionTask.new('temporalio_bridge', GEMSPEC) do |ext|
+    ext.lib_dir = 'lib/temporalio/internal/bridge'
+  end
+rescue RbSys::CargoMetadataError
+  raise 'Source gem cannot be installed directly, must be a supported platform'
+end
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.warning = false
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+def add_protoc_to_path
+  tools_spec = Gem::Specification.find_by_name('grpc-tools')
+  cpu = RbConfig::CONFIG['host_cpu']
+  cpu = 'x86_64' if cpu == 'x64'
+  os = RbConfig::CONFIG['host_os']
+  os = 'windows' if os.start_with?('mingw')
+  protoc_path = "#{tools_spec.gem_dir}/bin/#{cpu}-#{os}"
+  separator = os == 'windows' ? ';' : ':'
+  ENV['PATH'] = "#{ENV.fetch('PATH', nil)}#{separator}#{protoc_path}"
+end
+
+add_protoc_to_path
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+require 'steep/rake_task'
+
+Steep::RakeTask.new
+
+require 'yard'
+
+module CustomizeYardWarnings # rubocop:disable Style/Documentation
+  def process
+    super
+  rescue YARD::Parser::UndocumentableError
+    # We ignore if it's an API warning
+    raise unless statement.last.file.start_with?('lib/temporalio/api/') ||
+                 statement.last.file.start_with?('lib/temporalio/internal/bridge/api/')
+  end
+end
+
+YARD::Handlers::Ruby::ConstantHandler.prepend(CustomizeYardWarnings)
+
+YARD::Rake::YardocTask.new { |t| t.options = ['--fail-on-warning'] }
+
+require 'fileutils'
+require 'google/protobuf'
+
+namespace :proto do
+  desc 'Generate API and Core protobufs'
+  task :generate do
+    # Remove all existing
+    FileUtils.rm_rf('lib/temporalio/api')
+
+    def generate_protos(api_protos)
+      # Generate API to temp dir and move
+      FileUtils.rm_rf('tmp-proto')
+      FileUtils.mkdir_p('tmp-proto')
+      sh 'bundle exec grpc_tools_ruby_protoc ' \
+         '--proto_path=ext/sdk-core/sdk-core-protos/protos/api_upstream ' \
+         '--proto_path=ext/sdk-core/sdk-core-protos/protos/api_cloud_upstream ' \
+         '--proto_path=ext/additional_protos ' \
+         '--ruby_out=tmp-proto ' \
+         "#{api_protos.join(' ')}"
+
+      # Walk all generated Ruby files and cleanup content and filename
+      Dir.glob('tmp-proto/temporal/api/**/*.rb') do |path|
+        # Fix up the import
+        content = File.read(path)
+        content.gsub!(%r{^require 'temporal/(.*)_pb'$}, "require 'temporalio/\\1'")
+        File.write(path, content)
+
+        # Remove _pb from the filename
+        FileUtils.mv(path, path.sub('_pb', ''))
+      end
+
+      # Move from temp dir and remove temp dir
+      FileUtils.cp_r('tmp-proto/temporal/api', 'lib/temporalio')
+      FileUtils.rm_rf('tmp-proto')
+    end
+
+    # Generate from API with Google ones removed
+    generate_protos(Dir.glob('ext/sdk-core/sdk-core-protos/protos/api_upstream/**/*.proto').reject do |proto|
+      proto.include?('google')
+    end)
+
+    # Generate from Cloud API
+    generate_protos(Dir.glob('ext/sdk-core/sdk-core-protos/protos/api_cloud_upstream/**/*.proto'))
+
+    # Generate additional protos
+    generate_protos(Dir.glob('ext/additional_protos/**/*.proto'))
+
+    # Write files that will help with imports. We are requiring the
+    # request_response and not the service because the service depends on Google
+    # API annotations we don't want to have to depend on.
+    File.write(
+      'lib/temporalio/api/cloud/cloudservice.rb',
+      <<~TEXT
+        # frozen_string_literal: true
+
+        require 'temporalio/api/cloud/cloudservice/v1/request_response'
+      TEXT
+    )
+    File.write(
+      'lib/temporalio/api/workflowservice.rb',
+      <<~TEXT
+        # frozen_string_literal: true
+
+        require 'temporalio/api/workflowservice/v1/request_response'
+      TEXT
+    )
+    File.write(
+      'lib/temporalio/api/operatorservice.rb',
+      <<~TEXT
+        # frozen_string_literal: true
+
+        require 'temporalio/api/operatorservice/v1/request_response'
+      TEXT
+    )
+    File.write(
+      'lib/temporalio/api.rb',
+      <<~TEXT
+        # frozen_string_literal: true
+
+        require 'temporalio/api/cloud/cloudservice'
+        require 'temporalio/api/common/v1/grpc_status'
+        require 'temporalio/api/errordetails/v1/message'
+        require 'temporalio/api/operatorservice'
+        require 'temporalio/api/workflowservice'
+
+        module Temporalio
+          # Raw protocol buffer models.
+          module Api
+          end
+        end
+      TEXT
+    )
+
+    # Write the service classes that have the RPC calls
+    def write_service_file(qualified_service_name:, file_name:, class_name:, service_enum:)
+      # Do service lookup
+      desc = Google::Protobuf::DescriptorPool.generated_pool.lookup(qualified_service_name)
+      raise 'Failed finding service descriptor' unless desc
+
+      # Open file to generate Ruby code
+      File.open("lib/temporalio/client/connection/#{file_name}.rb", 'w') do |file|
+        file.puts <<~TEXT
+          # frozen_string_literal: true
+
+          # Generated code.  DO NOT EDIT!
+
+          require 'temporalio/api'
+          require 'temporalio/client/connection/service'
+          require 'temporalio/internal/bridge/client'
+
+          module Temporalio
+            class Client
+              class Connection
+                # #{class_name} API.
+                class #{class_name} < Service
+                  # @!visibility private
+                  def initialize(connection)
+                    super(connection, Internal::Bridge::Client::#{service_enum})
+                  end
+        TEXT
+
+        desc.each do |method|
+          # Camel case to snake case
+          rpc = method.name.gsub(/([A-Z])/, '_\1').downcase.delete_prefix('_')
+          file.puts <<-TEXT
+
+        # Calls #{class_name}.#{method.name} API call.
+        #
+        # @param request [#{method.input_type.msgclass}] API request.
+        # @param rpc_retry [Boolean] Whether to implicitly retry known retryable errors.
+        # @param rpc_metadata [Hash<String, String>, nil] Headers to include on the RPC call.
+        # @param rpc_timeout [Float, nil] Number of seconds before timeout.
+        # @return [#{method.output_type.msgclass}] API response.
+        def #{rpc}(request, rpc_retry: false, rpc_metadata: nil, rpc_timeout: nil)
+          invoke_rpc(
+            rpc: '#{rpc}',
+            request_class: #{method.input_type.msgclass},
+            response_class: #{method.output_type.msgclass},
+            request:,
+            rpc_retry:,
+            rpc_metadata:,
+            rpc_timeout:
+          )
+        end
+          TEXT
+        end
+
+        file.puts <<~TEXT
+                end
+              end
+            end
+          end
+        TEXT
+      end
+
+      # Open file to generate RBS code
+      # TODO(cretz): Improve this when RBS proto is supported
+      File.open("sig/temporalio/client/connection/#{file_name}.rbs", 'w') do |file|
+        file.puts <<~TEXT
+          # Generated code.  DO NOT EDIT!
+
+          module Temporalio
+            class Client
+              class Connection
+                class #{class_name} < Service
+                  def initialize: (Connection) -> void
+        TEXT
+
+        desc.each do |method|
+          # Camel case to snake case
+          rpc = method.name.gsub(/([A-Z])/, '_\1').downcase.delete_prefix('_')
+          file.puts <<-TEXT
+        def #{rpc}: (untyped request, ?rpc_retry: bool, ?rpc_metadata: Hash[String, String]?, ?rpc_timeout: Float?) -> untyped
+          TEXT
+        end
+
+        file.puts <<~TEXT
+                end
+              end
+            end
+          end
+        TEXT
+      end
+    end
+
+    require './lib/temporalio/api/workflowservice/v1/service'
+    write_service_file(
+      qualified_service_name: 'temporal.api.workflowservice.v1.WorkflowService',
+      file_name: 'workflow_service',
+      class_name: 'WorkflowService',
+      service_enum: 'SERVICE_WORKFLOW'
+    )
+    require './lib/temporalio/api/operatorservice/v1/service'
+    write_service_file(
+      qualified_service_name: 'temporal.api.operatorservice.v1.OperatorService',
+      file_name: 'operator_service',
+      class_name: 'OperatorService',
+      service_enum: 'SERVICE_OPERATOR'
+    )
+    require './lib/temporalio/api/cloud/cloudservice/v1/service'
+    write_service_file(
+      qualified_service_name: 'temporal.api.cloud.cloudservice.v1.CloudService',
+      file_name: 'cloud_service',
+      class_name: 'CloudService',
+      service_enum: 'SERVICE_CLOUD'
+    )
+
+    # Generate Rust code
+    def generate_rust_match_arm(file:, qualified_service_name:, service_enum:, trait:)
+      # Do service lookup
+      desc = Google::Protobuf::DescriptorPool.generated_pool.lookup(qualified_service_name)
+      file.puts <<~TEXT
+        #{service_enum} => match call.rpc.as_str() {
+      TEXT
+
+      desc.to_a.sort_by(&:name).each do |method|
+        # Camel case to snake case
+        rpc = method.name.gsub(/([A-Z])/, '_\1').downcase.delete_prefix('_')
+        file.puts <<~TEXT
+          "#{rpc}" => rpc_call!(self, callback, call, #{trait}, #{rpc}),
+        TEXT
+      end
+      file.puts <<~TEXT
+          _ => Err(error!("Unknown RPC call {}", call.rpc)),
+        },
+      TEXT
+    end
+    File.open('ext/src/client_rpc_generated.rs', 'w') do |file|
+      file.puts <<~TEXT
+        // Generated code.  DO NOT EDIT!
+
+        use magnus::{Error, Ruby};
+        use temporal_client::{CloudService, OperatorService, WorkflowService};
+
+        use super::{error, rpc_call};
+        use crate::{
+            client::{Client, RpcCall, SERVICE_CLOUD, SERVICE_OPERATOR, SERVICE_WORKFLOW},
+            util::AsyncCallback,
+        };
+
+        impl Client {
+            pub fn invoke_rpc(&self, service: u8, callback: AsyncCallback, call: RpcCall) -> Result<(), Error> {
+                match service {
+      TEXT
+      generate_rust_match_arm(
+        file:,
+        qualified_service_name: 'temporal.api.workflowservice.v1.WorkflowService',
+        service_enum: 'SERVICE_WORKFLOW',
+        trait: 'WorkflowService'
+      )
+      generate_rust_match_arm(
+        file:,
+        qualified_service_name: 'temporal.api.operatorservice.v1.OperatorService',
+        service_enum: 'SERVICE_OPERATOR',
+        trait: 'OperatorService'
+      )
+      generate_rust_match_arm(
+        file:,
+        qualified_service_name: 'temporal.api.cloud.cloudservice.v1.CloudService',
+        service_enum: 'SERVICE_CLOUD',
+        trait: 'CloudService'
+      )
+      file.puts <<~TEXT
+                    _ => Err(error!("Unknown service")),
+                }
+            }
+        }
+      TEXT
+    end
+    sh 'cargo', 'fmt', '--', 'ext/src/client_rpc_generated.rs'
+
+    # Generate core protos
+    FileUtils.rm_rf('lib/temporalio/internal/bridge/api')
+    # Generate API to temp dir
+    FileUtils.rm_rf('tmp-proto')
+    FileUtils.mkdir_p('tmp-proto')
+    sh 'bundle exec grpc_tools_ruby_protoc ' \
+       '--proto_path=ext/sdk-core/sdk-core-protos/protos/api_upstream ' \
+       '--proto_path=ext/sdk-core/sdk-core-protos/protos/local ' \
+       '--ruby_out=tmp-proto ' \
+       "#{Dir.glob('ext/sdk-core/sdk-core-protos/protos/local/**/*.proto').join(' ')}"
+    # Walk all generated Ruby files and cleanup content and filename
+    Dir.glob('tmp-proto/temporal/sdk/**/*.rb') do |path|
+      # Fix up the imports
+      content = File.read(path)
+      content.gsub!(%r{^require 'temporal/(.*)_pb'$}, "require 'temporalio/\\1'")
+      content.gsub!(%r{^require 'temporalio/sdk/core/(.*)'$}, "require 'temporalio/internal/bridge/api/\\1'")
+      File.write(path, content)
+
+      # Remove _pb from the filename
+      FileUtils.mv(path, path.sub('_pb', ''))
+    end
+    # Move from temp dir and remove temp dir
+    FileUtils.mkdir_p('lib/temporalio/internal/bridge/api')
+    FileUtils.cp_r(Dir.glob('tmp-proto/temporal/sdk/core/*'), 'lib/temporalio/internal/bridge/api')
+    FileUtils.rm_rf('tmp-proto')
+  end
+end
+
+namespace :rbs do
+  desc 'RBS tasks'
+  task :install_collection do
+    sh 'rbs collection install'
+  end
+end
+
+# We have to copy some parent files to this dir for gem
+task :copy_parent_files do
+  cp '../LICENSE', 'LICENSE'
+  cp '../README.md', 'README.md'
+end
+Rake::Task[:build].enhance([:copy_parent_files]) do
+  rm ['LICENSE', 'README.md']
+end
+
+task :rust_lint do
+  sh 'cargo', 'clippy'
+  sh 'cargo', 'fmt', '--check'
+end
+
+task default: ['rubocop', 'yard', 'rbs:install_collection', 'steep', 'rust_lint', 'compile', 'test']

data/lib/temporalio/activity/complete_async_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'temporalio/error'
+
+module Temporalio
+  class Activity
+    # Error raised inside an activity to mark that the activity will be completed asynchronously.
+    class CompleteAsyncError < Error
+    end
+  end
+end

data/lib/temporalio/activity/context.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'temporalio/error'
+
+module Temporalio
+  class Activity
+    # Context accessible only within an activity. Use {current} to get the current context. Contexts are fiber or thread
+    # local so may not be available in a newly started thread from an activity and may have to be propagated manually.
+    class Context
+      # @return [Context] The current context, or raises an error if not in activity fiber/thread.
+      def self.current
+        context = current_or_nil
+        raise Error, 'Not in activity context' if context.nil?
+
+        context
+      end
+
+      # @return [Context, nil] The current context or nil if not in activity fiber/thread.
+      def self.current_or_nil
+        _current_executor&.activity_context
+      end
+
+      # @return [Boolean] Whether there is a current context available.
+      def self.exist?
+        !current_or_nil.nil?
+      end
+
+      # @!visibility private
+      def self._current_executor
+        if Fiber.current_scheduler
+          Fiber[:temporal_activity_executor]
+        else
+          Thread.current[:temporal_activity_executor]
+        end
+      end
+
+      # @!visibility private
+      def self._current_executor=(executor)
+        if Fiber.current_scheduler
+          Fiber[:temporal_activity_executor] = executor
+        else
+          Thread.current[:temporal_activity_executor] = executor
+        end
+      end
+
+      # @return [Info] Activity info for this activity.
+      def info
+        raise NotImplementedError
+      end
+
+      # Record a heartbeat on the activity.
+      #
+      # Heartbeats should be used for all non-immediately-returning, non-local activities and they are required to
+      # receive cancellation. Heartbeat calls are throttled internally based on the heartbeat timeout of the activity.
+      # Users do not have to be concerned with burdening the server by calling this too frequently.
+      #
+      # @param details [Array<Object>] Details to record with the heartbeat.
+      def heartbeat(*details)
+        raise NotImplementedError
+      end
+
+      # @return [Cancellation] Cancellation that is canceled when the activity is canceled.
+      def cancellation
+        raise NotImplementedError
+      end
+
+      # @return [Cancellation] Cancellation that is canceled when the worker is shutting down. On worker shutdown, this
+      #   is canceled, then the `graceful_shutdown_period` is waited (default 0s), then the activity is canceled.
+      def worker_shutdown_cancellation
+        raise NotImplementedError
+      end
+
+      # @return [Converters::PayloadConverter] Payload converter associated with this activity.
+      def payload_converter
+        raise NotImplementedError
+      end
+
+      # @return [ScopedLogger] Logger for this activity. Note, this is a shared logger not created each activity
+      #   invocation. It just has logic to extract current activity details and so is only able to do so on log calls
+      #   made with a current context available.
+      def logger
+        raise NotImplementedError
+      end
+
+      # @!visibility private
+      def _scoped_logger_info
+        return @scoped_logger_info unless @scoped_logger_info.nil?
+
+        curr_info = info
+        @scoped_logger_info = {
+          temporal_activity: {
+            activity_id: curr_info.activity_id,
+            activity_type: curr_info.activity_type,
+            attempt: curr_info.attempt,
+            task_queue: curr_info.task_queue,
+            workflow_id: curr_info.workflow_id,
+            workflow_namespace: curr_info.workflow_namespace,
+            workflow_run_id: curr_info.workflow_run_id,
+            workflow_type: curr_info.workflow_type
+          }
+        }.freeze
+      end
+
+      # TODO(cretz): metric meter
+    end
+  end
+end

data/lib/temporalio/activity/definition.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Temporalio
+  class Activity
+    # Definition of an activity. Activities are usually classes/instances that extend {Activity}, but definitions can
+    # also be manually created with a proc/block.
+    class Definition
+      # @return [String, Symbol] Name of the activity.
+      attr_reader :name
+
+      # @return [Proc] Proc for the activity.
+      attr_reader :proc
+
+      # @return [Symbol] Name of the executor. Default is `:default`.
+      attr_reader :executor
+
+      # @return [Boolean] Whether to raise in thread/fiber on cancellation. Default is `true`.
+      attr_reader :cancel_raise
+
+      # Obtain a definition representing the given activity, which can be a class, instance, or definition.
+      #
+      # @param activity [Activity, Class<Activity>, Definition] Activity to get definition for.
+      # @return Definition Obtained definition.
+      def self.from_activity(activity)
+        # Class means create each time, instance means just call, definition
+        # does nothing special
+        case activity
+        when Class
+          raise ArgumentError, "Class '#{activity}' does not extend Activity" unless activity < Activity
+
+          details = activity._activity_definition_details
+          new(
+            name: details[:activity_name],
+            executor: details[:activity_executor],
+            cancel_raise: details[:activity_cancel_raise],
+            # Instantiate and call
+            proc: proc { |*args| activity.new.execute(*args) }
+          )
+        when Activity
+          details = activity.class._activity_definition_details
+          new(
+            name: details[:activity_name],
+            executor: details[:activity_executor],
+            cancel_raise: details[:activity_cancel_raise],
+            # Just call
+            proc: proc { |*args| activity.execute(*args) }
+          )
+        when Activity::Definition
+          activity
+        else
+          raise ArgumentError, "#{activity} is not an activity class, instance, or definition"
+        end
+      end
+
+      # Manually create activity definition. Most users will use an instance/class of {Activity}.
+      #
+      # @param name [String, Symbol] Name of the activity.
+      # @param proc [Proc, nil] Proc for the activity, or can give block.
+      # @param executor [Symbol] Name of the executor.
+      # @param cancel_raise [Boolean] Whether to raise in thread/fiber on cancellation.
+      # @yield Use this block as the activity. Cannot be present with `proc`.
+      def initialize(name:, proc: nil, executor: :default, cancel_raise: true, &block)
+        @name = name
+        if proc.nil?
+          raise ArgumentError, 'Must give proc or block' unless block_given?
+
+          proc = block
+        elsif block_given?
+          raise ArgumentError, 'Cannot give proc and block'
+        end
+        @proc = proc
+        @executor = executor
+        @cancel_raise = cancel_raise
+      end
+    end
+  end
+end

data/lib/temporalio/activity/info.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Temporalio
+  class Activity
+    # Information about an activity.
+    #
+    # @!attribute activity_id
+    #   @return [String] ID for the activity.
+    # @!attribute activity_type
+    #   @return [String] Type name for the activity.
+    # @!attribute attempt
+    #   @return [Integer] Attempt the activity is on.
+    # @!attribute current_attempt_scheduled_time
+    #   @return [Time] When the current attempt was scheduled.
+    # @!attribute heartbeat_details
+    #   @return [Array<Object>] Details from the last heartbeat of the last attempt.
+    # @!attribute heartbeat_timeout
+    #   @return [Float, nil] Heartbeat timeout set by the caller.
+    # @!attribute local?
+    #   @return [Boolean] Whether the activity is a local activity or not.
+    # @!attribute schedule_to_close_timeout
+    #   @return [Float, nil] Schedule to close timeout set by the caller.
+    # @!attribute scheduled_time
+    #   @return [Time] When the activity was scheduled.
+    # @!attribute start_to_close_timeout
+    #   @return [Float, nil] Start to close timeout set by the caller.
+    # @!attribute started_time
+    #   @return [Time] When the activity started.
+    # @!attribute task_queue
+    #   @return [String] Task queue this activity is on.
+    # @!attribute task_token
+    #   @return [String] Task token uniquely identifying this activity. Note, this is a `ASCII-8BIT` encoded string, not
+    #     a `UTF-8` encoded string nor a valid UTF-8 string.
+    # @!attribute workflow_id
+    #   @return [String] Workflow ID that started this activity.
+    # @!attribute workflow_namespace
+    #   @return [String] Namespace this activity is on.
+    # @!attribute workflow_run_id
+    #   @return [String] Workflow run ID that started this activity.
+    # @!attribute workflow_type
+    #   @return [String] Workflow type name that started this activity.
+    Info = Struct.new(
+      :activity_id,
+      :activity_type,
+      :attempt,
+      :current_attempt_scheduled_time,
+      :heartbeat_details,
+      :heartbeat_timeout,
+      :local?,
+      :schedule_to_close_timeout,
+      :scheduled_time,
+      :start_to_close_timeout,
+      :started_time,
+      :task_queue,
+      :task_token,
+      :workflow_id,
+      :workflow_namespace,
+      :workflow_run_id,
+      :workflow_type,
+      keyword_init: true
+    )
+  end
+end