mongo 1.10.0-java

data/test/replica_set/insert_test.rb

@@ -0,0 +1,140 @@
+# Copyright (C) 2009-2013 MongoDB, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'test_helper'
+
+class ReplicaSetInsertTest < Test::Unit::TestCase
+
+  def setup
+    ensure_cluster(:rs)
+    @client = MongoReplicaSetClient.new @rs.repl_set_seeds
+    @version = @client.server_version
+    @db = @client.db(TEST_DB)
+    @db.drop_collection("test-sets")
+    @coll = @db.collection("test-sets")
+  end
+
+  def teardown
+    @client.close if @conn
+  end
+
+  def test_insert
+    @coll.save({:a => 20}, :w => 3)
+
+    @rs.primary.stop
+
+    rescue_connection_failure do
+      @coll.save({:a => 30}, :w => 1)
+    end
+
+    @coll.save({:a => 40}, :w => 1)
+    @coll.save({:a => 50}, :w => 1)
+    @coll.save({:a => 60}, :w => 1)
+    @coll.save({:a => 70}, :w => 1)
+
+    # Restart the old master and wait for sync
+    @rs.start
+    sleep(5)
+    results = []
+
+    rescue_connection_failure do
+      @coll.find.each {|r| results << r}
+      [20, 30, 40, 50, 60, 70].each do |a|
+        assert results.any? {|r| r['a'] == a}, "Could not find record for a => #{a}"
+      end
+    end
+
+    @coll.save({:a => 80}, :w => 3)
+    @coll.find.each {|r| results << r}
+    [20, 30, 40, 50, 60, 70, 80].each do |a|
+      assert results.any? {|r| r['a'] == a}, "Could not find record for a => #{a} on second find"
+    end
+  end
+
+  context "Bulk API CollectionView" do
+    setup do
+      setup
+    end
+
+    should "handle error with deferred write concern error - spec Merging Results" do
+      with_write_commands_and_operations(@db.connection) do |wire_version|
+        @coll.remove
+        @coll.ensure_index(BSON::OrderedHash[:a, Mongo::ASCENDING], {:unique => true})
+        bulk = @coll.initialize_ordered_bulk_op
+        bulk.insert({:a => 1})
+        bulk.find({:a => 2}).upsert.update({'$set' => {:a => 2}})
+        bulk.insert({:a => 1})
+        ex = assert_raise BulkWriteError do
+          bulk.execute({:w => 5, :wtimeout => 1})
+        end
+        result = ex.result
+        assert_match_document(
+            {
+                "ok" => 1,
+                "n" => 2,
+                "writeErrors" => [
+                    {
+                        "index" => 2,
+                        "code" => 11000,
+                        "errmsg" => /duplicate key error/,
+                    }
+                ],
+                "writeConcernError" => [
+                    {
+                        "errmsg" => /waiting for replication timed out|timed out waiting for slaves|timeout/,
+                        "code" => 64,
+                        "errInfo" => {"wtimeout" => true},
+                        "index" => 0
+                    },
+                    {
+                        "errmsg" => /waiting for replication timed out|timed out waiting for slaves|timeout/,
+                        "code" => 64,
+                        "errInfo" => {"wtimeout" => true},
+                        "index" => 1
+                    }
+                ],
+                "code" => 65,
+                "errmsg" => "batch item errors occurred",
+                "nInserted" => 1
+            }, result, "wire_version:#{wire_version}")
+      end
+      assert_equal 2, @coll.find.to_a.size
+    end
+
+    should "handle unordered errors with deferred write concern error - spec Merging Results" do # TODO - spec review
+      with_write_commands_and_operations(@db.connection) do |wire_version|
+        @coll.remove
+        @coll.ensure_index(BSON::OrderedHash[:a, Mongo::ASCENDING], {:unique => true})
+        bulk = @coll.initialize_unordered_bulk_op
+        bulk.insert({:a => 1})
+        bulk.find({:a => 2}).upsert.update({'$set' => {:a => 1}})
+        bulk.insert({:a => 3})
+        ex = assert_raise BulkWriteError do
+          bulk.execute({:w => 5, :wtimeout => 1})
+        end
+        result = ex.result # unordered varies, don't use assert_bulk_exception
+        assert_equal(1, result["ok"], "wire_version:#{wire_version}")
+        assert_equal(2, result["n"], "wire_version:#{wire_version}")
+        assert(result["nInserted"] >= 1, "wire_version:#{wire_version}")
+        assert_equal(65, result["code"], "wire_version:#{wire_version}")
+        assert_equal("batch item errors occurred", result["errmsg"], "wire_version:#{wire_version}")
+        assert(result["writeErrors"].size >= 1,  "wire_version:#{wire_version}")
+        assert(result["writeConcernError"].size >= 1, "wire_version:#{wire_version}") if wire_version >= 2
+        assert(@coll.size >= 1, "wire_version:#{wire_version}")
+      end
+    end
+
+  end
+
+end

data/test/replica_set/max_values_test.rb

@@ -0,0 +1,145 @@
+# Copyright (C) 2009-2013 MongoDB, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'test_helper'
+
+class MaxValuesTest < Test::Unit::TestCase
+
+  include Mongo
+
+  def setup
+    ensure_cluster(:rs)
+    @client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :name => @rs.repl_set_name)
+    @db = new_mock_db
+    @client.stubs(:[]).returns(@db)
+    @ismaster = {
+      'hosts' => @client.local_manager.hosts.to_a,
+      'arbiters' => @client.local_manager.arbiters
+    }
+  end
+
+  def test_initial_max_and_min_values
+    assert @client.max_bson_size
+    assert @client.max_message_size
+    assert @client.max_wire_version
+    assert @client.min_wire_version
+  end
+
+  def test_updated_max_and_min_sizes_after_node_config_change
+    @db.stubs(:command).returns(
+      @ismaster.merge({'ismaster' => true}),
+      @ismaster.merge({'secondary' => true, 'maxMessageSizeBytes' => 1024 * MESSAGE_SIZE_FACTOR}),
+      @ismaster.merge({'secondary' => true, 'maxBsonObjectSize' => 1024}),
+      @ismaster.merge({'secondary' => true, 'maxWireVersion' => 0}),
+      @ismaster.merge({'secondary' => true, 'minWireVersion' => 0})
+    )
+    @client.local_manager.stubs(:refresh_required?).returns(true)
+    @client.refresh
+
+    assert_equal 1024, @client.max_bson_size
+    assert_equal 1024 * MESSAGE_SIZE_FACTOR, @client.max_message_size
+    assert_equal 0, @client.max_wire_version
+    assert_equal 0, @client.min_wire_version
+  end
+
+  def test_no_values_in_config
+    @db.stubs(:command).returns(
+      @ismaster.merge({'ismaster' => true}),
+      @ismaster.merge({'secondary' => true}),
+      @ismaster.merge({'secondary' => true})
+    )
+    @client.local_manager.stubs(:refresh_required?).returns(true)
+    @client.refresh
+
+    assert_equal DEFAULT_MAX_BSON_SIZE, @client.max_bson_size
+    assert_equal DEFAULT_MAX_BSON_SIZE * MESSAGE_SIZE_FACTOR, @client.max_message_size
+    assert_equal 0, @client.max_wire_version
+    assert_equal 0, @client.min_wire_version
+  end
+
+  def test_only_bson_size_in_config
+    @db.stubs(:command).returns(
+      @ismaster.merge({'ismaster' => true}),
+      @ismaster.merge({'secondary' => true}),
+      @ismaster.merge({'secondary' => true, 'maxBsonObjectSize' => 1024})
+    )
+    @client.local_manager.stubs(:refresh_required?).returns(true)
+    @client.refresh
+
+    assert_equal 1024, @client.max_bson_size
+    assert_equal 1024 * MESSAGE_SIZE_FACTOR, @client.max_message_size
+    assert_equal 0, @client.max_wire_version
+    assert_equal 0, @client.min_wire_version
+  end
+
+  def test_values_in_config
+    #ismaster is called three times on the first node
+    @db.stubs(:command).returns(
+      @ismaster.merge({'ismaster' => true, 'maxMessageSizeBytes' => 1024 * 2 * MESSAGE_SIZE_FACTOR,
+                       'maxBsonObjectSize' => 1024, 'maxWireVersion' => 2, 'minWireVersion' => 1}),
+      @ismaster.merge({'ismaster' => true, 'maxMessageSizeBytes' => 1024 * 2 * MESSAGE_SIZE_FACTOR,
+                       'maxBsonObjectSize' => 1024, 'maxWireVersion' => 2, 'minWireVersion' => 1}),
+      @ismaster.merge({'ismaster' => true, 'maxMessageSizeBytes' => 1024 * 2 * MESSAGE_SIZE_FACTOR,
+                       'maxBsonObjectSize' => 1024, 'maxWireVersion' => 2, 'minWireVersion' => 1}),
+      @ismaster.merge({'secondary' => true, 'maxMessageSizeBytes' => 1024 * 2 * MESSAGE_SIZE_FACTOR,
+                       'maxBsonObjectSize' => 1024, 'maxWireVersion' => 2, 'minWireVersion' => 0}),
+      @ismaster.merge({'secondary' => true, 'maxMessageSizeBytes' => 1024 * 2 * MESSAGE_SIZE_FACTOR,
+                       'maxBsonObjectSize' => 1024, 'maxWireVersion' => 1, 'minWireVersion' => 0})
+    )
+    @client.local_manager.stubs(:refresh_required?).returns(true)
+    @client.refresh
+
+    assert_equal 1024, @client.max_bson_size
+    assert_equal 1024 * 2 * MESSAGE_SIZE_FACTOR, @client.max_message_size
+    assert_equal 1, @client.max_wire_version # minimum of all max_wire_version
+    assert_equal 1, @client.min_wire_version # maximum of all min_wire_version
+  end
+
+  def test_wire_version_not_in_range
+    min_wire_version, max_wire_version = [Mongo::MongoClient::MIN_WIRE_VERSION-1, Mongo::MongoClient::MIN_WIRE_VERSION-1]
+    #ismaster is called three times on the first node
+    @db.stubs(:command).returns(
+      @ismaster.merge({'ismaster' => true, 'maxWireVersion' => max_wire_version, 'minWireVersion' => min_wire_version}),
+      @ismaster.merge({'ismaster' => true, 'maxWireVersion' => max_wire_version, 'minWireVersion' => min_wire_version}),
+      @ismaster.merge({'ismaster' => true, 'maxWireVersion' => max_wire_version, 'minWireVersion' => min_wire_version}),
+      @ismaster.merge({'secondary' => true, 'maxWireVersion' => max_wire_version, 'minWireVersion' => min_wire_version}),
+      @ismaster.merge({'secondary' => true, 'maxWireVersion' => max_wire_version, 'minWireVersion' => min_wire_version})
+    )
+    @client.local_manager.stubs(:refresh_required?).returns(true)
+    assert_raises Mongo::ConnectionFailure do
+      @client.refresh
+    end
+  end
+
+  def test_use_write_command
+    with_write_commands(@client) do
+      assert_true @client.use_write_command?({:w => 1})
+      assert_false @client.use_write_command?({:w => 0})
+    end
+    with_write_operations(@client) do
+      assert_false @client.use_write_command?({:w => 1})
+      assert_false @client.use_write_command?({:w => 0})
+    end
+    @client.local_manager.primary_pool.node.expects(:wire_version_feature?).at_least_once.returns(true)
+    assert_true @client.use_write_command?({:w => 1})
+    assert_false @client.use_write_command?({:w => 0})
+  end
+
+  def test_max_write_batch_size
+    assert_equal Mongo::MongoClient::DEFAULT_MAX_WRITE_BATCH_SIZE, @client.max_write_batch_size
+    @client.local_manager.primary_pool.node.stubs(:max_write_batch_size).returns(999)
+    assert_equal 999, @client.max_write_batch_size
+  end
+end
+

data/test/replica_set/pinning_test.rb

@@ -0,0 +1,55 @@
+# Copyright (C) 2009-2013 MongoDB, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'test_helper'
+
+class ReplicaSetPinningTest < Test::Unit::TestCase
+  def setup
+    ensure_cluster(:rs)
+    @client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :name => @rs.repl_set_name)
+    @db = @client.db(TEST_DB)
+    @coll = @db.collection("test-sets")
+    @coll.insert({:a => 1})
+  end
+
+  def test_unpinning
+    # pin primary
+    @coll.find_one
+    assert_equal @client.pinned_pool[:pool], @client.primary_pool
+
+    # pin secondary
+    @coll.find_one({}, :read => :secondary_preferred)
+    assert @client.secondary_pools.include? @client.pinned_pool[:pool]
+
+    # repin primary
+    @coll.find_one({}, :read => :primary_preferred)
+    assert_equal @client.pinned_pool[:pool], @client.primary_pool
+  end
+
+  def test_pinned_pool_is_local_to_thread
+    threads = []
+    30.times do |i|
+      threads << Thread.new do
+        if i % 2 == 0
+          @coll.find_one({}, :read => :secondary_preferred)
+          assert @client.secondary_pools.include? @client.pinned_pool[:pool]
+        else
+          @coll.find_one({}, :read => :primary_preferred)
+          assert_equal @client.pinned_pool[:pool], @client.primary_pool
+        end
+      end
+    end
+    threads.each(&:join)
+  end
+end

data/test/replica_set/query_test.rb

@@ -0,0 +1,73 @@
+# Copyright (C) 2009-2013 MongoDB, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'test_helper'
+
+class ReplicaSetQueryTest < Test::Unit::TestCase
+
+  def setup
+    ensure_cluster(:rs)
+    @client = MongoReplicaSetClient.new @rs.repl_set_seeds
+    @db = @client.db(TEST_DB)
+    @db.drop_collection("test-sets")
+    @coll = @db.collection("test-sets")
+  end
+
+  def teardown
+    @client.close if @conn
+  end
+
+  def test_query
+    @coll.save({:a => 20}, :w => 3)
+    @coll.save({:a => 30}, :w => 3)
+    @coll.save({:a => 40}, :w => 3)
+    results = []
+    @coll.find.each {|r| results << r}
+    [20, 30, 40].each do |a|
+      assert results.any? {|r| r['a'] == a}, "Could not find record for a => #{a}"
+    end
+
+    @rs.primary.stop
+
+    results = []
+    rescue_connection_failure do
+      @coll.find.each {|r| results << r}
+      [20, 30, 40].each do |a|
+        assert results.any? {|r| r['a'] == a}, "Could not find record for a => #{a}"
+      end
+    end
+  end
+
+  # Create a large collection and do a secondary query that returns
+  # enough records to require sending a GETMORE. In between opening
+  # the cursor and sending the GETMORE, do a :primary query. Confirm
+  # that the cursor reading from the secondary continues to talk to
+  # the secondary, rather than trying to read the cursor from the
+  # primary, where it does not exist.
+  # def test_secondary_getmore
+  #   200.times do |i|
+  #     @coll.save({:a => i}, :w => 3)
+  #   end
+  #   as = []
+  #   # Set an explicit batch size, in case the default ever changes.
+  #   @coll.find({}, { :batch_size => 100, :read => :secondary }) do |c|
+  #     c.each do |result|
+  #       as << result['a']
+  #       @coll.find({:a => result['a']}, :read => :primary).map
+  #     end
+  #   end
+  #   assert_equal(as.sort, 0.upto(199).to_a)
+  # end
+
+end

data/test/replica_set/read_preference_test.rb

@@ -0,0 +1,214 @@
+# Copyright (C) 2009-2013 MongoDB, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'test_helper'
+
+class ReadPreferenceTest < Test::Unit::TestCase
+
+  def setup
+    ensure_cluster(:rs, :replicas => 2, :arbiters => 0)
+
+    # Insert data
+    primary = @rs.primary
+    conn = Connection.new(primary.host, primary.port)
+    db = conn.db(TEST_DB)
+    coll = db.collection("test-sets")
+    coll.save({:a => 20}, {:w => 2})
+  end
+
+  def test_read_primary
+    conn = make_connection
+    rescue_connection_failure do
+      assert conn.read_primary?
+      assert conn.primary?
+    end
+
+    conn = make_connection(:primary_preferred)
+    rescue_connection_failure do
+      assert conn.read_primary?
+      assert conn.primary?
+    end
+
+    conn = make_connection(:secondary)
+    rescue_connection_failure do
+      assert !conn.read_primary?
+      assert !conn.primary?
+    end
+
+    conn = make_connection(:secondary_preferred)
+    rescue_connection_failure do
+      assert !conn.read_primary?
+      assert !conn.primary?
+    end
+  end
+
+  def test_connection_pools
+    conn = make_connection
+    assert conn.primary_pool, "No primary pool!"
+    assert conn.read_pool, "No read pool!"
+    assert conn.primary_pool.port == conn.read_pool.port,
+      "Primary port and read port are not the same!"
+
+    conn = make_connection(:primary_preferred)
+    assert conn.primary_pool, "No primary pool!"
+    assert conn.read_pool, "No read pool!"
+    assert conn.primary_pool.port == conn.read_pool.port,
+      "Primary port and read port are not the same!"
+
+    conn = make_connection(:secondary)
+    assert conn.primary_pool, "No primary pool!"
+    assert conn.read_pool, "No read pool!"
+    assert conn.primary_pool.port != conn.read_pool.port,
+      "Primary port and read port are the same!"
+
+    conn = make_connection(:secondary_preferred)
+    assert conn.primary_pool, "No primary pool!"
+    assert conn.read_pool, "No read pool!"
+    assert conn.primary_pool.port != conn.read_pool.port,
+      "Primary port and read port are the same!"
+  end
+
+  def test_read_routing
+    prepare_routing_test
+
+    # Test that reads are going to the right members
+    assert_query_route(@primary, @primary_direct)
+    assert_query_route(@primary_preferred, @primary_direct)
+    assert_query_route(@secondary, @secondary_direct)
+    assert_query_route(@secondary_preferred, @secondary_direct)
+  end
+
+  def test_read_routing_with_primary_down
+    prepare_routing_test
+
+    # Test that reads are going to the right members
+    assert_query_route(@primary, @primary_direct)
+    assert_query_route(@primary_preferred, @primary_direct)
+    assert_query_route(@secondary, @secondary_direct)
+    assert_query_route(@secondary_preferred, @secondary_direct)
+
+    # Kill the primary so only a single secondary exists
+    @rs.primary.kill
+
+    # Test that reads are going to the right members
+    assert_raise_error ConnectionFailure do
+      @primary[TEST_DB]['test-sets'].find_one
+    end
+    assert_query_route(@primary_preferred, @secondary_direct)
+    assert_query_route(@secondary, @secondary_direct)
+    assert_query_route(@secondary_preferred, @secondary_direct)
+
+    # Restore set
+    @rs.restart
+    sleep(1)
+    @repl_cons.each { |con| con.refresh }
+    sleep(1)
+    @primary_direct = Connection.new(
+      @rs.config['host'],
+      @primary.read_pool.port
+    )
+
+    # Test that reads are going to the right members
+    assert_query_route(@primary, @primary_direct)
+    assert_query_route(@primary_preferred, @primary_direct)
+    assert_query_route(@secondary, @secondary_direct)
+    assert_query_route(@secondary_preferred, @secondary_direct)
+  end
+
+  def test_read_routing_with_secondary_down
+    prepare_routing_test
+
+    # Test that reads are going to the right members
+    assert_query_route(@primary, @primary_direct)
+    assert_query_route(@primary_preferred, @primary_direct)
+    assert_query_route(@secondary, @secondary_direct)
+    assert_query_route(@secondary_preferred, @secondary_direct)
+
+    # Kill the secondary so that only primary exists
+    @rs.secondaries.first.kill
+
+    # Test that reads are going to the right members
+    assert_query_route(@primary, @primary_direct)
+    assert_query_route(@primary_preferred, @primary_direct)
+    assert_raise_error ConnectionFailure do
+      @secondary[TEST_DB]['test-sets'].find_one
+    end
+    assert_query_route(@secondary_preferred, @primary_direct)
+
+    # Restore set
+    @rs.restart
+    sleep(1)
+    @repl_cons.each { |con| con.refresh }
+    sleep(1)
+    @secondary_direct = Connection.new(
+      @rs.config['host'],
+      @secondary.read_pool.port,
+      :slave_ok => true
+    )
+
+    # Test that reads are going to the right members
+    assert_query_route(@primary, @primary_direct)
+    assert_query_route(@primary_preferred, @primary_direct)
+    assert_query_route(@secondary, @secondary_direct)
+    assert_query_route(@secondary_preferred, @secondary_direct)
+  end
+
+  def test_write_lots_of_data
+    @conn = make_connection(:secondary_preferred)
+    @db = @conn[TEST_DB]
+    @coll = @db.collection("test-sets", {:w => 2})
+
+    6000.times do |n|
+      @coll.save({:a => n})
+    end
+
+    cursor = @coll.find()
+    cursor.next
+    cursor.close
+  end
+
+  private
+
+  def prepare_routing_test
+    # Setup replica set connections
+    @primary = make_connection(:primary)
+    @primary_preferred = make_connection(:primary_preferred)
+    @secondary = make_connection(:secondary)
+    @secondary_preferred = make_connection(:secondary_preferred)
+    @repl_cons = [@primary, @primary_preferred, @secondary, @secondary_preferred]
+
+    # Setup direct connections
+    @primary_direct = Connection.new(@rs.config['host'], @primary.read_pool.port)
+    @secondary_direct = Connection.new(@rs.config['host'], @secondary.read_pool.port, :slave_ok => true)
+  end
+
+  def make_connection(mode = :primary, opts = {})
+    opts.merge!({:read => mode})
+    MongoReplicaSetClient.new(@rs.repl_set_seeds, opts)
+  end
+
+  def query_count(connection)
+    connection['admin'].command({:serverStatus => 1})['opcounters']['query']
+  end
+
+  def assert_query_route(test_connection, expected_target)
+    #puts "#{test_connection.read_pool.port} #{expected_target.read_pool.port}"
+    queries_before = query_count(expected_target)
+    assert_nothing_raised do
+      test_connection[TEST_DB]['test-sets'].find_one
+    end
+    queries_after = query_count(expected_target)
+    assert_equal 1, queries_after - queries_before
+  end
+end