def test_sg_replicate_push_async(params_from_base_test_setup, num_docs):
assert num_docs > 0
# if the async stuff works, we should be able to kick off a large
# push replication and get a missing doc before the replication has
# a chance to finish. And then we should later see that doc.
cluster_config = params_from_base_test_setup["cluster_config"]
mode = params_from_base_test_setup["mode"]
log_info("Running 'test_sg_replicate_push_async'")
log_info("Using cluster_config: {}".format(cluster_config))
config = sync_gateway_config_path_for_mode("sync_gateway_sg_replicate", mode)
sg1, sg2 = create_sync_gateways(
cluster_config=cluster_config,
sg_config_path=config
)
admin = Admin(sg1)
admin.admin_url = sg1.url
sg1_user, sg2_user = create_sg_users(sg1, sg2, DB1, DB2)
# Add docs to sg1
doc_ids_added = []
last_doc_id_added = None
for i in xrange(num_docs):
doc_id = sg1_user.add_doc()
doc_ids_added.append(doc_id)
last_doc_id_added = doc_id
# Wait until doc shows up on sg1's changes feed
wait_until_doc_in_changes_feed(sg1, DB1, last_doc_id_added)
# try to get the last doc added from the target -- assert that we get an exception
assert_does_not_have_doc(sg2_user, last_doc_id_added)
# kick off a one-off push replication with async=true
sg1.start_push_replication(
sg2.admin.admin_url,
DB1,
DB2,
continuous=False,
use_remote_source=True,
async=True,
use_admin_url=True
)
# wait until that doc shows up on the target
wait_until_doc_sync(sg2_user, last_doc_id_added)
# At this point, the active tasks should be empty
wait_until_active_tasks_empty(sg1)
def test_sg_replicate_push_async(params_from_base_test_setup, num_docs):
assert num_docs > 0
# if the async stuff works, we should be able to kick off a large
# push replication and get a missing doc before the replication has
# a chance to finish. And then we should later see that doc.
cluster_config = params_from_base_test_setup["cluster_config"]
mode = params_from_base_test_setup["mode"]
log_info("Running 'test_sg_replicate_push_async'")
log_info("Using cluster_config: {}".format(cluster_config))
config = sync_gateway_config_path_for_mode("sync_gateway_sg_replicate", mode)
sg1, sg2 = create_sync_gateways(
cluster_config=cluster_config,
sg_config_path=config
)
admin = Admin(sg1)
admin.admin_url = sg1.url
sg1_user, sg2_user = create_sg_users(sg1, sg2, DB1, DB2)
# Add docs to sg1
doc_ids_added = []
last_doc_id_added = None
for i in xrange(num_docs):
doc_id = sg1_user.add_doc()
doc_ids_added.append(doc_id)
last_doc_id_added = doc_id
# Wait until doc shows up on sg1's changes feed
wait_until_doc_in_changes_feed(sg1, DB1, last_doc_id_added)
# try to get the last doc added from the target -- assert that we get an exception
assert_does_not_have_doc(sg2_user, last_doc_id_added)
# kick off a one-off push replication with async=true
sg1.start_push_replication(
sg2.admin.admin_url,
DB1,
DB2,
continuous=False,
use_remote_source=True,
async=True,
use_admin_url=True
)
# wait until that doc shows up on the target
wait_until_doc_sync(sg2_user, last_doc_id_added)
# At this point, the active tasks should be empty
wait_until_active_tasks_empty(sg1)
def test_sg_replicate_basic_test_channels(params_from_base_test_setup):
cluster_config = params_from_base_test_setup["cluster_config"]
mode = params_from_base_test_setup["mode"]
log_info("Running 'test_sg_replicate_basic_test_channels'")
log_info("Using cluster_config: {}".format(cluster_config))
config = sync_gateway_config_path_for_mode("sync_gateway_sg_replicate", mode)
sg1, sg2 = create_sync_gateways(
cluster_config=cluster_config,
sg_config_path=config
)
admin = Admin(sg1)
admin.admin_url = sg1.url
sg1a_user, sg1b_user, sg2_user = create_sg_users_channels(sg1, sg2, DB1, DB2)
# Add docs to sg1 in channel A and channel B
doc_id_sg1a = sg1a_user.add_doc()
doc_id_sg1b = sg1b_user.add_doc()
# Wait until docs show up in changes feed
wait_until_doc_in_changes_feed(sg1, DB1, doc_id_sg1a)
wait_until_doc_in_changes_feed(sg1, DB1, doc_id_sg1b)
# Make sure it doesn't appear on the target DB
# even without starting a replication (which will
# happen if the SG's are sharing a CB bucket)
time.sleep(5)
assert_does_not_have_doc(sg2_user, doc_id_sg1a)
assert_does_not_have_doc(sg2_user, doc_id_sg1b)
# Start a push replication sg1 -> sg2
chans = sg1a_user.channels
sg1.start_push_replication(
sg2.admin.admin_url,
DB1,
DB2,
continuous=False,
use_remote_source=True,
channels=chans,
use_admin_url=True
)
# Verify that the doc added to sg1 made it to sg2
assert_has_doc(sg2_user, doc_id_sg1a)
def test_sg_replicate_basic_test_channels(params_from_base_test_setup):
cluster_config = params_from_base_test_setup["cluster_config"]
mode = params_from_base_test_setup["mode"]
log_info("Running 'test_sg_replicate_basic_test_channels'")
log_info("Using cluster_config: {}".format(cluster_config))
config = sync_gateway_config_path_for_mode("sync_gateway_sg_replicate", mode)
sg1, sg2 = create_sync_gateways(
cluster_config=cluster_config,
sg_config_path=config
)
admin = Admin(sg1)
admin.admin_url = sg1.url
sg1a_user, sg1b_user, sg2_user = create_sg_users_channels(sg1, sg2, DB1, DB2)
# Add docs to sg1 in channel A and channel B
doc_id_sg1a = sg1a_user.add_doc()
doc_id_sg1b = sg1b_user.add_doc()
# Wait until docs show up in changes feed
wait_until_doc_in_changes_feed(sg1, DB1, doc_id_sg1a)
wait_until_doc_in_changes_feed(sg1, DB1, doc_id_sg1b)
# Make sure it doesn't appear on the target DB
# even without starting a replication (which will
# happen if the SG's are sharing a CB bucket)
time.sleep(5)
assert_does_not_have_doc(sg2_user, doc_id_sg1a)
assert_does_not_have_doc(sg2_user, doc_id_sg1b)
# Start a push replication sg1 -> sg2
chans = sg1a_user.channels
sg1.start_push_replication(
sg2.admin.admin_url,
DB1,
DB2,
continuous=False,
use_remote_source=True,
channels=chans,
use_admin_url=True
)
# Verify that the doc added to sg1 made it to sg2
assert_has_doc(sg2_user, doc_id_sg1a)
def test_sg_replicate_basic_test(params_from_base_test_setup):
cluster_config = params_from_base_test_setup["cluster_config"]
mode = params_from_base_test_setup["mode"]
log_info("Running 'test_sg_replicate_basic_test'")
log_info("Using cluster_config: {}".format(cluster_config))
config = sync_gateway_config_path_for_mode("sync_gateway_sg_replicate", mode)
sg1, sg2 = create_sync_gateways(
cluster_config=cluster_config,
sg_config_path=config
)
admin = Admin(sg1)
admin.admin_url = sg1.url
sg1_user, sg2_user = create_sg_users(sg1, sg2, DB1, DB2)
# Add docs to sg1 and sg2
doc_id_sg1 = sg1_user.add_doc()
doc_id_sg2 = sg2_user.add_doc()
# Wait until docs show up in changes feed
wait_until_doc_in_changes_feed(sg1, DB1, doc_id_sg1)
wait_until_doc_in_changes_feed(sg2, DB2, doc_id_sg2)
# Make sure it doesn't appear on the target DB
# even without starting a replication (which will
# happen if the SG's are sharing a CB bucket)
time.sleep(5)
assert_does_not_have_doc(sg2_user, doc_id_sg1)
assert_does_not_have_doc(sg1_user, doc_id_sg2)
# Start a push replication sg1 -> sg2
# Should block until replication
# Result should contain the stats of the completed replication
replication_result = sg1.start_push_replication(
sg2.admin.admin_url,
DB1,
DB2,
continuous=False,
use_remote_source=True,
use_admin_url=True
)
logging.debug("replication_result 1: {}".format(replication_result))
assert replication_result["continuous"] is False, 'replication_result["continuous"] != False'
assert replication_result["docs_written"] == 1, 'replication_result["docs_written"] != 1'
assert replication_result["docs_read"] == 1, 'replication_result["docs_read"] != 1'
assert replication_result["doc_write_failures"] == 0, 'replication_result["doc_write_failures"] != 0'
# Start a pull replication sg1 <- sg2
replication_result = sg1.start_pull_replication(
sg2.admin.admin_url,
DB2,
DB1,
continuous=False,
use_remote_target=True,
use_admin_url=True
)
logging.debug("replication_result 2: {}".format(replication_result))
assert replication_result["continuous"] is False, 'replication_result["continuous"] != False'
assert replication_result["docs_written"] == 1, 'replication_result["docs_written"] != 1'
assert replication_result["docs_read"] == 1, 'replication_result["docs_read"] != 1'
assert replication_result["doc_write_failures"] == 0, 'replication_result["doc_write_failures"] != 0'
# Verify that the doc added to sg1 made it to sg2
assert_has_doc(sg2_user, doc_id_sg1)
# Verify that the doc added to sg2 made it to sg1
assert_has_doc(sg1_user, doc_id_sg2)
def test_sg_replicate_continuous_replication(params_from_base_test_setup):
cluster_config = params_from_base_test_setup["cluster_config"]
mode = params_from_base_test_setup["mode"]
log_info("Running 'test_sg_replicate_continuous_replication'")
log_info("Using cluster_config: {}".format(cluster_config))
config = sync_gateway_config_path_for_mode("sync_gateway_sg_replicate", mode)
sg1, sg2 = create_sync_gateways(
cluster_config=cluster_config,
sg_config_path=config
)
# Create users (in order to add docs)
sg1_user, sg2_user = create_sg_users(sg1, sg2, DB1, DB2)
# Kick off continuous replication
sg1.start_push_replication(
sg2.admin.admin_url,
DB1,
DB2,
continuous=True,
use_remote_source=True,
use_admin_url=True
)
# Add docs
doc_id = sg1_user.add_doc()
# Wait til all docs sync to target
wait_until_docs_sync(sg2_user, [doc_id])
# Shutdown target
sg2.stop()
# Add more docs
doc_id_2 = sg1_user.add_doc()
# Wait a few seconds to give the source replicator time to have some attempts
time.sleep(5)
# Restart target
config = sync_gateway_config_path_for_mode("sync_gateway_sg_replicate", mode)
sg2.start(config=config)
# Wait til all docs sync to target
wait_until_docs_sync(sg2_user, [doc_id, doc_id_2])
# Stop replications
sg1.stop_push_replication(
sg2.admin.admin_url,
DB1,
DB2,
continuous=True,
use_remote_source=True,
use_admin_url=True
)
# Wait until active_tasks is empty (or throw exception)
wait_until_active_tasks_empty(sg1)
# Add more docs, even though the replication is already stopped
doc_id_3 = sg1_user.add_doc()
# Wait a few seconds to give it time to potentially propagate
time.sleep(5)
# Make sure the doc did not propagate to the target
assert_does_not_have_doc(sg2_user, doc_id_3)
def test_sg_replicate_basic_test(params_from_base_test_setup):
cluster_config = params_from_base_test_setup["cluster_config"]
mode = params_from_base_test_setup["mode"]
log_info("Running 'test_sg_replicate_basic_test'")
log_info("Using cluster_config: {}".format(cluster_config))
config = sync_gateway_config_path_for_mode("sync_gateway_sg_replicate", mode)
sg1, sg2 = create_sync_gateways(
cluster_config=cluster_config,
sg_config_path=config
)
admin = Admin(sg1)
admin.admin_url = sg1.url
sg1_user, sg2_user = create_sg_users(sg1, sg2, DB1, DB2)
# Add docs to sg1 and sg2
doc_id_sg1 = sg1_user.add_doc()
doc_id_sg2 = sg2_user.add_doc()
# Wait until docs show up in changes feed
wait_until_doc_in_changes_feed(sg1, DB1, doc_id_sg1)
wait_until_doc_in_changes_feed(sg2, DB2, doc_id_sg2)
# Make sure it doesn't appear on the target DB
# even without starting a replication (which will
# happen if the SG's are sharing a CB bucket)
time.sleep(5)
assert_does_not_have_doc(sg2_user, doc_id_sg1)
assert_does_not_have_doc(sg1_user, doc_id_sg2)
# Start a push replication sg1 -> sg2
# Should block until replication
# Result should contain the stats of the completed replication
replication_result = sg1.start_push_replication(
sg2.admin.admin_url,
DB1,
DB2,
continuous=False,
use_remote_source=True,
use_admin_url=True
)
logging.debug("replication_result 1: {}".format(replication_result))
assert replication_result["continuous"] is False, 'replication_result["continuous"] != False'
assert replication_result["docs_written"] == 1, 'replication_result["docs_written"] != 1'
assert replication_result["docs_read"] == 1, 'replication_result["docs_read"] != 1'
assert replication_result["doc_write_failures"] == 0, 'replication_result["doc_write_failures"] != 0'
# Start a pull replication sg1 <- sg2
replication_result = sg1.start_pull_replication(
sg2.admin.admin_url,
DB2,
DB1,
continuous=False,
use_remote_target=True,
use_admin_url=True
)
logging.debug("replication_result 2: {}".format(replication_result))
assert replication_result["continuous"] is False, 'replication_result["continuous"] != False'
assert replication_result["docs_written"] == 1, 'replication_result["docs_written"] != 1'
assert replication_result["docs_read"] == 1, 'replication_result["docs_read"] != 1'
assert replication_result["doc_write_failures"] == 0, 'replication_result["doc_write_failures"] != 0'
# Verify that the doc added to sg1 made it to sg2
assert_has_doc(sg2_user, doc_id_sg1)
# Verify that the doc added to sg2 made it to sg1
assert_has_doc(sg1_user, doc_id_sg2)
def test_sg_replicate_continuous_replication(params_from_base_test_setup):
cluster_config = params_from_base_test_setup["cluster_config"]
mode = params_from_base_test_setup["mode"]
log_info("Running 'test_sg_replicate_continuous_replication'")
log_info("Using cluster_config: {}".format(cluster_config))
config = sync_gateway_config_path_for_mode("sync_gateway_sg_replicate", mode)
sg1, sg2 = create_sync_gateways(
cluster_config=cluster_config,
sg_config_path=config
)
# Create users (in order to add docs)
sg1_user, sg2_user = create_sg_users(sg1, sg2, DB1, DB2)
# Kick off continuous replication
sg1.start_push_replication(
sg2.admin.admin_url,
DB1,
DB2,
continuous=True,
use_remote_source=True,
use_admin_url=True
)
# Add docs
doc_id = sg1_user.add_doc()
# Wait til all docs sync to target
wait_until_docs_sync(sg2_user, [doc_id])
# Shutdown target
sg2.stop()
# Add more docs
doc_id_2 = sg1_user.add_doc()
# Wait a few seconds to give the source replicator time to have some attempts
time.sleep(5)
# Restart target
config = sync_gateway_config_path_for_mode("sync_gateway_sg_replicate", mode)
sg2.start(config=config)
# Wait til all docs sync to target
wait_until_docs_sync(sg2_user, [doc_id, doc_id_2])
# Stop replications
sg1.stop_push_replication(
sg2.admin.admin_url,
DB1,
DB2,
continuous=True,
use_remote_source=True,
use_admin_url=True
)
# Wait until active_tasks is empty (or throw exception)
wait_until_active_tasks_empty(sg1)
# Add more docs, even though the replication is already stopped
doc_id_3 = sg1_user.add_doc()
# Wait a few seconds to give it time to potentially propagate
time.sleep(5)
# Make sure the doc did not propagate to the target
assert_does_not_have_doc(sg2_user, doc_id_3)