def start_polling_changes_worker(sg_url, sg_db, user_name, user_auth,
changes_delay, changes_limit,
terminator_doc_id, feed, channels_filtered,
doc_ids_filtered):
sg_client = MobileRestClient()
since = 0
latest_changes = {}
found_terminator = False
# Pass a channel filter to changes request if filtered is true
filter_type = None
filter_channels = None
filter_doc_ids = None
if channels_filtered:
filter_type = 'sync_gateway/bychannel'
filter_channels = ['even', 'terminator']
elif doc_ids_filtered:
filter_type = '_doc_ids'
filter_doc_ids = ['terminator']
while True:
# If terminator doc is found, terminate the polling loop
if found_terminator:
log_info('Found terminator ({}, {})'.format(user_name, feed))
return user_name, latest_changes
log_info('_changes ({}) for ({}) since: {}'.format(
feed, user_name, since))
changes = sg_client.get_changes(url=sg_url,
db=sg_db,
since=since,
auth=user_auth,
feed=feed,
limit=changes_limit,
filter_type=filter_type,
filter_channels=filter_channels,
filter_doc_ids=filter_doc_ids)
# A termination doc was processed, exit on the next loop
for change in changes['results']:
if change['id'] == terminator_doc_id:
found_terminator = True
else:
# Add latest rev to to latest_changes map
if len(change['changes']) >= 1:
latest_changes[change['id']] = change['changes'][0]['rev']
else:
latest_changes[change['id']] = ''
since = changes['last_seq']
time.sleep(changes_delay)
def test_longpoll_awaken_channels(params_from_base_test_setup, sg_conf_name):
cluster_conf = params_from_base_test_setup["cluster_config"]
cluster_topology = params_from_base_test_setup["cluster_topology"]
mode = params_from_base_test_setup["mode"]
sg_conf = sync_gateway_config_path_for_mode(sg_conf_name, mode)
sg_admin_url = cluster_topology["sync_gateways"][0]["admin"]
sg_url = cluster_topology["sync_gateways"][0]["public"]
log_info("sg_conf: {}".format(sg_conf))
log_info("sg_admin_url: {}".format(sg_admin_url))
log_info("sg_url: {}".format(sg_url))
cluster = Cluster(config=cluster_conf)
cluster.reset(sg_config_path=sg_conf)
adam_user_info = userinfo.UserInfo(name="adam", password="******", channels=["NBC", "ABC"], roles=[])
traun_user_info = userinfo.UserInfo(name="traun", password="******", channels=[], roles=[])
andy_user_info = userinfo.UserInfo(name="andy", password="******", channels=[], roles=[])
sg_db = "db"
doc_id = "adam_doc_0"
client = MobileRestClient()
adam_auth = client.create_user(url=sg_admin_url, db=sg_db,
name=adam_user_info.name, password=adam_user_info.password, channels=adam_user_info.channels)
traun_auth = client.create_user(url=sg_admin_url, db=sg_db,
name=traun_user_info.name, password=traun_user_info.password, channels=traun_user_info.channels)
andy_auth = client.create_user(url=sg_admin_url, db=sg_db,
name=andy_user_info.name, password=andy_user_info.password, channels=andy_user_info.channels)
############################################################
# changes feed wakes with Channel Access via Admin API
############################################################
# Get starting sequence of docs, use the last seq to progress past any _user docs.
adam_changes = client.get_changes(url=sg_url, db=sg_db, since=0, feed="normal", auth=adam_auth)
traun_changes = client.get_changes(url=sg_url, db=sg_db, since=0, feed="normal", auth=traun_auth)
andy_changes = client.get_changes(url=sg_url, db=sg_db, since=0, feed="normal", auth=andy_auth)
with concurrent.futures.ProcessPoolExecutor() as ex:
# Start changes feed for 3 users
adam_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=adam_changes["last_seq"], timeout=10, auth=adam_auth)
traun_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=traun_changes["last_seq"], timeout=10, auth=traun_auth)
andy_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=andy_changes["last_seq"], timeout=10, auth=andy_auth)
# Wait for changes feed to notice there are no changes and enter wait. 2 seconds should be more than enough
time.sleep(2)
# Make sure the changes future is still running and has not exited due to any new changes, the feed should be caught up
# and waiting
assert not adam_changes_task.done()
assert not traun_changes_task.done()
assert not andy_changes_task.done()
# Add add a doc for adam with "NBC" and "ABC" channels
# Add one doc, this should wake up the changes feed
adam_add_docs_task = ex.submit(client.add_docs, url=sg_url, db=sg_db,
number=1, id_prefix="adam_doc",
auth=adam_auth, channels=adam_user_info.channels)
# Wait for docs adds to complete
adam_docs = adam_add_docs_task.result()
assert len(adam_docs) == 1
# Assert that the changes feed woke up and that the doc change was propagated
adam_changes = adam_changes_task.result()
assert len(adam_changes["results"]) == 1
assert adam_changes["results"][0]["id"] == doc_id
# Verify that the changes feed is still listening for Traun and Andy
assert not traun_changes_task.done()
assert not andy_changes_task.done()
# Update the traun and andy to have one of adam's channels
update_traun_user_task = ex.submit(client.update_user, url=sg_admin_url, db=sg_db,
name=traun_user_info.name, password=traun_user_info.password, channels=["NBC"])
traun_auth = update_traun_user_task.result()
update_andy_user_task = ex.submit(client.update_user, url=sg_admin_url, db=sg_db,
name=andy_user_info.name, password=andy_user_info.password, channels=["ABC"])
andy_auth = update_andy_user_task.result()
# Make sure changes feed wakes up and contains at least one change, 2 may be possible if the _user doc is included
# Make sure the first change is 'adam_doc'
traun_changes = traun_changes_task.result()
assert 1 <= len(traun_changes["results"]) <= 2
assert traun_changes["results"][0]["id"] == "adam_doc_0" or traun_changes["results"][0]["id"] == "_user/traun"
andy_changes = andy_changes_task.result()
assert 1 <= len(andy_changes["results"]) <= 2
assert andy_changes["results"][0]["id"] == "adam_doc_0" or andy_changes["results"][0]["id"] == "_user/andy"
# Block until user docs are seen
client.verify_doc_id_in_changes(url=sg_url, db=sg_db, expected_doc_id="_user/adam", auth=adam_auth)
client.verify_doc_id_in_changes(url=sg_url, db=sg_db, expected_doc_id="_user/traun", auth=traun_auth)
client.verify_doc_id_in_changes(url=sg_url, db=sg_db, expected_doc_id="_user/andy", auth=andy_auth)
# Make sure that adams doc shows up in changes due to the fact that the changes feed may be woken up with a _user doc above
client.verify_docs_in_changes(url=sg_url, db=sg_db, expected_docs=adam_docs, auth=adam_auth)
client.verify_docs_in_changes(url=sg_url, db=sg_db, expected_docs=adam_docs, auth=traun_auth)
client.verify_docs_in_changes(url=sg_url, db=sg_db, expected_docs=adam_docs, auth=andy_auth)
############################################################
# changes feed wakes with Channel Removal via Sync function
############################################################
# Get latest last_seq for next test section
adam_changes = client.get_changes(url=sg_url, db=sg_db, since=0, feed="normal", auth=adam_auth)
traun_changes = client.get_changes(url=sg_url, db=sg_db, since=0, feed="normal", auth=traun_auth)
andy_changes = client.get_changes(url=sg_url, db=sg_db, since=0, feed="normal", auth=andy_auth)
with concurrent.futures.ProcessPoolExecutor() as ex:
# Start changes feed for 3 users from latest last_seq
adam_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=adam_changes["last_seq"], timeout=10, auth=adam_auth)
traun_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=traun_changes["last_seq"], timeout=10, auth=traun_auth)
andy_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=andy_changes["last_seq"], timeout=10, auth=andy_auth)
# Wait for changes feed to notice there are no changes and enter wait. 2 seconds should be more than enough
time.sleep(2)
# Make sure the changes future is still running and has not exited due to any new changes, the feed should be caught up
# and waiting
assert not adam_changes_task.done()
assert not traun_changes_task.done()
assert not andy_changes_task.done()
# Remove the channels property from the doc
client.update_doc(url=sg_url, db=sg_db, doc_id=doc_id, auth=traun_auth, channels=[])
# All three changes feeds should wake up and return one result
adam_changes = adam_changes_task.result()
assert len(adam_changes["results"]) == 1
assert adam_changes["results"][0]["removed"] == ["ABC", "NBC"]
traun_changes = traun_changes_task.result()
assert len(traun_changes["results"]) == 1
assert traun_changes["results"][0]["removed"] == ["NBC"]
andy_changes = andy_changes_task.result()
assert len(andy_changes["results"]) == 1
assert andy_changes["results"][0]["removed"] == ["ABC"]
# Verify that users no longer can access the doc
for user_auth in [adam_auth, traun_auth, andy_auth]:
with pytest.raises(requests.exceptions.HTTPError) as excinfo:
client.get_doc(url=sg_url, db=sg_db, doc_id=doc_id, auth=user_auth)
assert "403 Client Error: Forbidden for url:" in excinfo.value.message
############################################################
# changes feed wakes with Channel Grant via Sync function
############################################################
# Get latest last_seq for next test section
adam_changes = client.get_changes(url=sg_url, db=sg_db, since=0, feed="normal", auth=adam_auth)
traun_changes = client.get_changes(url=sg_url, db=sg_db, since=0, feed="normal", auth=traun_auth)
andy_changes = client.get_changes(url=sg_url, db=sg_db, since=0, feed="normal", auth=andy_auth)
admin_auth = client.create_user(url=sg_admin_url, db=sg_db, name="admin", password="******", channels=["admin"])
channel_grant_doc_id = "channel_grant_with_doc_intially"
# Add another doc with no channels
channel_grant_doc_body = document.create_doc(doc_id=channel_grant_doc_id, channels=["admin"])
client.add_doc(url=sg_url, db=sg_db, doc=channel_grant_doc_body, auth=admin_auth)
with concurrent.futures.ProcessPoolExecutor() as ex:
# Start changes feed for 3 users from latest last_seq
adam_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=adam_changes["last_seq"], timeout=10, auth=adam_auth)
traun_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=traun_changes["last_seq"], timeout=10, auth=traun_auth)
andy_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=andy_changes["last_seq"], timeout=10, auth=andy_auth)
# Wait for changes feed to notice there are no changes and enter wait. 2 seconds should be more than enough
time.sleep(2)
# Make sure the changes future is still running and has not exited due to any new changes, the feed should be caught up
# and waiting
assert not adam_changes_task.done()
assert not traun_changes_task.done()
assert not andy_changes_task.done()
# update the grant doc to have channel for all users
update_task = ex.submit(client.update_doc, url=sg_url, db=sg_db, doc_id=channel_grant_doc_id, auth=admin_auth, channels=["admin", "ABC", "NBC"])
updated_doc = update_task.result()
assert updated_doc["rev"].startswith("2-")
# Verify that access grant wakes up changes feed for adam, traun, and Andy
adam_changes = adam_changes_task.result()
assert len(adam_changes["results"]) == 1
assert adam_changes["results"][0]["id"] == "channel_grant_with_doc_intially"
assert adam_changes["results"][0]["changes"][0]["rev"].startswith("2-")
traun_changes = traun_changes_task.result()
assert len(traun_changes["results"]) == 1
assert traun_changes["results"][0]["id"] == "channel_grant_with_doc_intially"
assert traun_changes["results"][0]["changes"][0]["rev"].startswith("2-")
andy_changes = andy_changes_task.result()
assert len(andy_changes["results"]) == 1
assert andy_changes["results"][0]["id"] == "channel_grant_with_doc_intially"
assert andy_changes["results"][0]["changes"][0]["rev"].startswith("2-")
def test_longpoll_awaken_doc_add_update(params_from_base_test_setup, sg_conf_name):
cluster_conf = params_from_base_test_setup["cluster_config"]
mode = params_from_base_test_setup["mode"]
cluster_topology = params_from_base_test_setup["cluster_topology"]
sg_conf = sync_gateway_config_path_for_mode(sg_conf_name, mode)
sg_admin_url = cluster_topology["sync_gateways"][0]["admin"]
sg_url = cluster_topology["sync_gateways"][0]["public"]
log_info("sg_conf: {}".format(sg_conf))
log_info("sg_admin_url: {}".format(sg_admin_url))
log_info("sg_url: {}".format(sg_url))
cluster = Cluster(config=cluster_conf)
cluster.reset(sg_config_path=sg_conf)
adam_user_info = userinfo.UserInfo(name="adam", password="******", channels=["NBC"], roles=[])
traun_user_info = userinfo.UserInfo(name="traun", password="******", channels=["CBS"], roles=[])
andy_user_info = userinfo.UserInfo(name="andy", password="******", channels=["MTV"], roles=[])
sg_db = "db"
client = MobileRestClient()
adam_auth = client.create_user(url=sg_admin_url, db=sg_db,
name=adam_user_info.name, password=adam_user_info.password, channels=adam_user_info.channels)
traun_auth = client.create_user(url=sg_admin_url, db=sg_db,
name=traun_user_info.name, password=traun_user_info.password, channels=traun_user_info.channels)
andy_auth = client.create_user(url=sg_admin_url, db=sg_db,
name=andy_user_info.name, password=andy_user_info.password, channels=andy_user_info.channels)
# Get starting sequence of docs, use the last seq to progress past any user docs
adam_changes = client.get_changes(url=sg_url, db=sg_db, since=0, feed="normal", auth=adam_auth)
traun_changes = client.get_changes(url=sg_url, db=sg_db, since=0, feed="normal", auth=traun_auth)
andy_changes = client.get_changes(url=sg_url, db=sg_db, since=0, feed="normal", auth=andy_auth)
with concurrent.futures.ProcessPoolExecutor() as ex:
adam_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=adam_changes["last_seq"], timeout=30, auth=adam_auth)
traun_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=traun_changes["last_seq"], timeout=30, auth=traun_auth)
andy_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=andy_changes["last_seq"], timeout=30, auth=andy_auth)
# Wait for changes feed to notice there are no changes and enter wait. 2 seconds should be more than enough
time.sleep(2)
# Make sure the changes future is still running and has not exited due to any new changes, the feed should be caught up
# and waiting
assert not adam_changes_task.done()
assert not traun_changes_task.done()
assert not andy_changes_task.done()
# Add 3 docs with adam auth, one with adam channels, one with traun channels, one with andy auth
# Tests the changes feed wakes up for user created docs and non user created docs
adam_add_doc_task_1 = ex.submit(client.add_docs, url=sg_url, db=sg_db,
number=1, id_prefix="adam_doc",
auth=adam_auth, channels=adam_user_info.channels)
adam_add_doc_task_2 = ex.submit(client.add_docs, url=sg_url, db=sg_db,
number=1, id_prefix="traun_doc",
auth=adam_auth, channels=traun_user_info.channels)
adam_add_doc_task_3 = ex.submit(client.add_docs, url=sg_url, db=sg_db,
number=1, id_prefix="andy_doc",
auth=adam_auth, channels=andy_user_info.channels)
# Wait for docs adds to complete
adam_doc_1 = adam_add_doc_task_1.result()
assert len(adam_doc_1) == 1
adam_doc_2 = adam_add_doc_task_2.result()
assert len(adam_doc_2) == 1
adam_doc_3 = adam_add_doc_task_3.result()
assert len(adam_doc_3) == 1
# Assert that the changes feed woke up and that the doc change was propagated
adam_changes = adam_changes_task.result()
assert len(adam_changes["results"]) == 1
assert adam_changes["results"][0]["id"] == "adam_doc_0"
traun_changes = traun_changes_task.result()
assert len(traun_changes["results"]) == 1
assert traun_changes["results"][0]["id"] == "traun_doc_0"
andy_changes = andy_changes_task.result()
assert len(andy_changes["results"]) == 1
assert andy_changes["results"][0]["id"] == "andy_doc_0"
# Start another longpoll changes request
adam_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=adam_changes["last_seq"], auth=adam_auth)
traun_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=traun_changes["last_seq"], auth=traun_auth)
andy_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=andy_changes["last_seq"], auth=andy_auth)
# Wait for changes feed to notice there are no changes and enter wait. 2 seconds should be more than enough
time.sleep(2)
# Make sure the changes future is still running and has not exited due to any new changes, the feed should be caught up
# and waiting
assert not adam_changes_task.done()
assert not traun_changes_task.done()
assert not andy_changes_task.done()
# Check to see that doc updates to own user doc wake up changes feed
adam_update_docs_task = ex.submit(client.update_docs, url=sg_url, db=sg_db, docs=adam_doc_1, number_updates=1, auth=adam_auth)
traun_update_docs_task = ex.submit(client.update_docs, url=sg_url, db=sg_db, docs=adam_doc_2, number_updates=1, auth=traun_auth)
andy_update_docs_task = ex.submit(client.update_docs, url=sg_url, db=sg_db, docs=adam_doc_3, number_updates=1, auth=andy_auth)
# Wait for docs updates to complete
adam_updated_docs = adam_update_docs_task.result()
assert len(adam_updated_docs) == 1
assert adam_updated_docs[0]["rev"].startswith("2-")
traun_updated_docs = traun_update_docs_task.result()
assert len(traun_updated_docs) == 1
assert traun_updated_docs[0]["rev"].startswith("2-")
andy_updated_docs = andy_update_docs_task.result()
assert len(andy_updated_docs) == 1
assert andy_updated_docs[0]["rev"].startswith("2-")
# Assert that the changes feed woke up and that the doc updates was propagated
adam_changes = adam_changes_task.result()
assert len(adam_changes["results"]) == 1
assert adam_changes["results"][0]["id"] == "adam_doc_0"
rev_from_change = int(adam_changes["results"][0]["changes"][0]["rev"].split("-")[0])
assert rev_from_change == 2
traun_changes = traun_changes_task.result()
assert len(traun_changes["results"]) == 1
assert traun_changes["results"][0]["id"] == "traun_doc_0"
rev_from_change = int(traun_changes["results"][0]["changes"][0]["rev"].split("-")[0])
assert rev_from_change == 2
andy_changes = andy_changes_task.result()
assert len(andy_changes["results"]) == 1
assert andy_changes["results"][0]["id"] == "andy_doc_0"
rev_from_change = int(andy_changes["results"][0]["changes"][0]["rev"].split("-")[0])
assert rev_from_change == 2
# Start another longpoll changes request from the last_seq
adam_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=adam_changes["last_seq"], auth=adam_auth)
traun_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=traun_changes["last_seq"], auth=traun_auth)
andy_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=andy_changes["last_seq"], auth=andy_auth)
# Wait for changes feed to notice there are no changes and enter wait. 2 seconds should be more than enough
time.sleep(2)
# Make sure the changes future is still running and has not exited due to any new changes, the feed should be caught up
# and waiting
assert not adam_changes_task.done()
assert not traun_changes_task.done()
assert not andy_changes_task.done()
# Add doc with access to all channels
adam_add_doc_task_4 = ex.submit(client.add_docs, url=sg_url, db=sg_db,
number=1, id_prefix="all_doc",
auth=adam_auth,
channels=adam_user_info.channels + traun_user_info.channels + andy_user_info.channels)
all_doc = adam_add_doc_task_4.result()
assert len(all_doc) == 1
# Assert that the changes feed woke up and that the doc add was propagated to all users
adam_changes = adam_changes_task.result()
assert len(adam_changes["results"]) == 1
assert adam_changes["results"][0]["id"] == "all_doc_0"
rev_from_change = int(adam_changes["results"][0]["changes"][0]["rev"].split("-")[0])
assert rev_from_change == 1
traun_changes = traun_changes_task.result()
assert len(traun_changes["results"]) == 1
assert traun_changes["results"][0]["id"] == "all_doc_0"
rev_from_change = int(traun_changes["results"][0]["changes"][0]["rev"].split("-")[0])
assert rev_from_change == 1
andy_changes = andy_changes_task.result()
assert len(andy_changes["results"]) == 1
assert andy_changes["results"][0]["id"] == "all_doc_0"
rev_from_change = int(andy_changes["results"][0]["changes"][0]["rev"].split("-")[0])
assert rev_from_change == 1
# Start another longpoll changes request from the last_seq
adam_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=adam_changes["last_seq"], auth=adam_auth)
traun_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=traun_changes["last_seq"], auth=traun_auth)
andy_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=andy_changes["last_seq"], auth=andy_auth)
# Wait for changes feed to notice there are no changes and enter wait. 2 seconds should be more than enough
time.sleep(2)
# Make sure the changes future is still running and has not exited due to any new changes, the feed should be caught up
# and waiting
assert not adam_changes_task.done()
assert not traun_changes_task.done()
assert not andy_changes_task.done()
# Update doc with access to all channels
adam_update_docs_task_2 = ex.submit(client.update_docs, url=sg_url, db=sg_db, docs=all_doc, number_updates=1, auth=adam_auth)
# Wait for docs updates to complete
all_doc_updated = adam_update_docs_task_2.result()
assert len(all_doc_updated) == 1
assert all_doc_updated[0]["rev"].startswith("2-")
# Assert that the changes feed woke up and that the doc update was propagated to all users
adam_changes = adam_changes_task.result()
assert len(adam_changes["results"]) == 1
assert adam_changes["results"][0]["id"] == "all_doc_0"
rev_from_change = int(adam_changes["results"][0]["changes"][0]["rev"].split("-")[0])
assert rev_from_change == 2
traun_changes = traun_changes_task.result()
assert len(traun_changes["results"]) == 1
assert traun_changes["results"][0]["id"] == "all_doc_0"
rev_from_change = int(traun_changes["results"][0]["changes"][0]["rev"].split("-")[0])
assert rev_from_change == 2
andy_changes = andy_changes_task.result()
assert len(andy_changes["results"]) == 1
assert andy_changes["results"][0]["id"] == "all_doc_0"
rev_from_change = int(andy_changes["results"][0]["changes"][0]["rev"].split("-")[0])
assert rev_from_change == 2
def test_backfill_channel_grant_to_role_longpoll(params_from_base_test_setup,
sg_conf_name, grant_type,
channels_to_grant):
"""
Test that check that docs are backfilled for a channel grant (via REST or SYNC) to existing role
1. Create a 'grantee' user with an empty role
2. 'pusher' user adds docs with channel(s) that will later be granted to 'grantee'
3. Verify that the 'pusher' sees the docs on its changes feed
4. Grant the 'grantee's role access to the pushers channels (either via REST or via sync function)
5. Verify that 'grantee' gets all of the docs after the grant
"""
cluster_config = params_from_base_test_setup["cluster_config"]
topology = params_from_base_test_setup["cluster_topology"]
mode = params_from_base_test_setup["mode"]
sg_url = topology["sync_gateways"][0]["public"]
sg_admin_url = topology["sync_gateways"][0]["admin"]
sg_db = "db"
num_docs_per_channel = 100
empty_role_name = "empty_role"
log_info("grant_type: {}".format(grant_type))
log_info("channels to grant access to: {}".format(channels_to_grant))
is_multi_channel_grant = False
if len(channels_to_grant) == 3:
is_multi_channel_grant = True
log_info("is_multi_channel_grant: {}".format(is_multi_channel_grant))
sg_conf = sync_gateway_config_path_for_mode(sg_conf_name, mode)
cluster = Cluster(cluster_config)
cluster.reset(sg_conf)
client = MobileRestClient()
client.create_role(url=sg_admin_url,
db=sg_db,
name=empty_role_name,
channels=[])
pusher_info = userinfo.UserInfo("pusher",
"pass",
channels=channels_to_grant,
roles=[])
grantee_info = userinfo.UserInfo("grantee",
"pass",
channels=[],
roles=[empty_role_name])
# Create users
client.create_user(url=sg_admin_url,
db=sg_db,
name=pusher_info.name,
password=pusher_info.password,
channels=pusher_info.channels,
roles=pusher_info.roles)
pusher_session = client.create_session(url=sg_admin_url,
db=sg_db,
name=pusher_info.name,
password=pusher_info.password)
client.create_user(url=sg_admin_url,
db=sg_db,
name=grantee_info.name,
password=grantee_info.password,
channels=grantee_info.channels,
roles=grantee_info.roles)
grantee_session = client.create_session(url=sg_admin_url,
db=sg_db,
name=grantee_info.name,
password=grantee_info.password)
pusher_changes = client.get_changes(url=sg_url,
db=sg_db,
since=0,
auth=pusher_session)
# Make sure _user docs shows up in the changes feed
assert len(pusher_changes["results"]
) == 1 and pusher_changes["results"][0]["id"] == "_user/pusher"
# Add docs with the appropriate channels
a_docs = client.add_docs(url=sg_url,
db=sg_db,
number=num_docs_per_channel,
id_prefix=None,
auth=pusher_session,
channels=["A"])
assert len(a_docs) == 100
expected_docs = a_docs
if is_multi_channel_grant:
b_docs = client.add_docs(url=sg_url,
db=sg_db,
number=num_docs_per_channel,
id_prefix=None,
auth=pusher_session,
channels=["B"])
assert len(b_docs) == 100
expected_docs += b_docs
c_docs = client.add_docs(url=sg_url,
db=sg_db,
number=num_docs_per_channel,
id_prefix=None,
auth=pusher_session,
channels=["C"])
assert len(c_docs) == 100
expected_docs += c_docs
# Wait for all docs to show up on the changes feed before access grant
client.verify_docs_in_changes(url=sg_url,
db=sg_db,
expected_docs=expected_docs,
auth=pusher_session)
# Get changes for granted before grant and assert the only changes is the user doc
grantee_changes_before_grant = client.get_changes(url=sg_url,
db=sg_db,
since=0,
auth=grantee_session)
assert len(grantee_changes_before_grant["results"]) == 1
assert grantee_changes_before_grant["results"][0]["id"] == "_user/grantee"
if grant_type == "CHANNEL-REST":
# Grant channel access to role via REST
client.update_role(url=sg_admin_url,
db=sg_db,
name=empty_role_name,
channels=channels_to_grant)
elif grant_type == "CHANNEL-SYNC":
# Grant channel access to role via sync function
access_doc = document.create_doc(doc_id="channel_grant_to_role")
access_doc["roles"] = ["role:{}".format(empty_role_name)]
access_doc["channels"] = channels_to_grant
client.add_doc(url=sg_url,
db=sg_db,
doc=access_doc,
auth=pusher_session,
use_post=True)
# Issue changes request after grant
grantee_changes_post_grant = client.get_changes(
url=sg_url,
db=sg_db,
since=grantee_changes_before_grant["last_seq"],
auth=grantee_session,
feed="longpoll")
# grantee should have all the docs now
if is_multi_channel_grant:
# Check that the grantee gets all of the docs for channels ["A", "B", "C"]
assert len(
grantee_changes_post_grant["results"]) == num_docs_per_channel * 3
else:
# Check that the grantee gets all of the docs for channels ["A"]
assert len(
grantee_changes_post_grant["results"]) == num_docs_per_channel
# Disable this conditional if https://github.com/couchbase/sync_gateway/issues/2277 is fixed
if mode == "di":
# Issue one more changes request from the post grant last seq and make sure there are no other changes
grantee_changes_post_post_grant = client.get_changes(
url=sg_url,
db=sg_db,
since=grantee_changes_post_grant["last_seq"],
auth=grantee_session,
feed="normal")
assert len(grantee_changes_post_post_grant["results"]) == 0
def test_awaken_backfill_channels_longpoll_changes_with_limit(
params_from_base_test_setup, sg_conf_name, grant_type):
"""
Test that checks that docs are backfilled for logpoll changes with limit for a access grant (via REST or SYNC)
CHANNEL-REST = Channel is granted to user via REST
CHANNEL-SYNC = Channel is granted to user via sync function access()
ROLE-REST = Role is granted to user via REST
ROLE-SYNC = Role is granted to user via sync function role()
CHANNEL-TO-ROLE-REST = Channel is added to existing role via REST
CHANNEL-TO-ROLE-SYNC = Channel is added to existing role via sync access()
"""
cluster_config = params_from_base_test_setup["cluster_config"]
topology = params_from_base_test_setup["cluster_topology"]
mode = params_from_base_test_setup["mode"]
sg_url = topology["sync_gateways"][0]["public"]
sg_admin_url = topology["sync_gateways"][0]["admin"]
sg_db = "db"
log_info("grant_type: {}".format(grant_type))
sg_conf = sync_gateway_config_path_for_mode(sg_conf_name, mode)
cluster = Cluster(cluster_config)
cluster.reset(sg_conf)
client = MobileRestClient()
admin_user_info = userinfo.UserInfo("admin",
"pass",
channels=["A"],
roles=[])
if grant_type == "CHANNEL-TO-ROLE-REST" or grant_type == "CHANNEL-TO-ROLE-SYNC":
client.create_role(url=sg_admin_url,
db=sg_db,
name="empty_role",
channels=[])
user_b_user_info = userinfo.UserInfo("USER_B",
"pass",
channels=["B"],
roles=["empty_role"])
else:
user_b_user_info = userinfo.UserInfo("USER_B",
"pass",
channels=["B"],
roles=[])
# Create users / sessions
client.create_user(
url=sg_admin_url,
db=sg_db,
name=admin_user_info.name,
password=admin_user_info.password,
channels=admin_user_info.channels,
)
client.create_user(url=sg_admin_url,
db=sg_db,
name=user_b_user_info.name,
password=user_b_user_info.password,
channels=user_b_user_info.channels,
roles=user_b_user_info.roles)
admin_session = client.create_session(url=sg_admin_url,
db=sg_db,
name=admin_user_info.name,
password=admin_user_info.password)
user_b_session = client.create_session(url=sg_admin_url,
db=sg_db,
name=user_b_user_info.name,
password=user_b_user_info.password)
# Create 50 "A" channel docs
a_docs = client.add_docs(url=sg_url,
db=sg_db,
number=50,
id_prefix=None,
auth=admin_session,
channels=["A"])
assert len(a_docs) == 50
b_docs = client.add_docs(url=sg_url,
db=sg_db,
number=1,
id_prefix="b_doc",
auth=user_b_session,
channels=["B"])
assert len(b_docs) == 1
user_doc = {"id": "_user/USER_B", "rev": None}
b_docs.append(user_doc)
# Loop until user_b sees b_doc_0 doc and _user/USER_B doc
client.verify_docs_in_changes(url=sg_url,
db=sg_db,
expected_docs=b_docs,
auth=user_b_session,
strict=True)
# Create a dictionary keyed on doc id for all of channel A docs
ids_and_revs_from_a_docs = {doc["id"]: doc["rev"] for doc in a_docs}
assert len(ids_and_revs_from_a_docs.keys()) == 50
# Get last_seq for user_b
user_b_changes = client.get_changes(url=sg_url,
db=sg_db,
since=0,
auth=user_b_session,
feed="normal")
with concurrent.futures.ThreadPoolExecutor(max_workers=10) as ex:
# Start long poll changes feed.
changes_task = ex.submit(client.get_changes,
url=sg_url,
db=sg_db,
since=user_b_changes["last_seq"],
auth=user_b_session,
timeout=10,
limit=20)
# Grant access to channel "A"
if grant_type == "CHANNEL-REST":
log_info(
"Granting user access to channel A via Admin REST user update")
# Grant via update to user in Admin API
client.update_user(url=sg_admin_url,
db=sg_db,
name=user_b_user_info.name,
channels=["A", "B"])
elif grant_type == "CHANNEL-SYNC":
log_info(
"Granting user access to channel A sync function access()")
# Grant via access() in sync_function,
# then id 'channel_access' will trigger an access(doc.users, doc.channels)
access_doc = document.create_doc("channel_access", channels=["A"])
access_doc["users"] = ["USER_B"]
client.add_doc(url=sg_url,
db=sg_db,
doc=access_doc,
auth=admin_session)
elif grant_type == "ROLE-REST":
log_info(
"Granting user access to channel A via Admin REST role grant")
# Create role with channel A
client.create_role(url=sg_admin_url,
db=sg_db,
name="channel-A-role",
channels=["A"])
client.update_user(url=sg_admin_url,
db=sg_db,
name=user_b_user_info.name,
roles=["channel-A-role"])
elif grant_type == "ROLE-SYNC":
log_info(
"Granting user access to channel A via sync function role() grant"
)
# Create role with channel A
client.create_role(url=sg_admin_url,
db=sg_db,
name="channel-A-role",
channels=["A"])
# Grant via role() in sync_function, then id 'role_access' will trigger an role(doc.users, doc.roles)
role_access_doc = document.create_doc("role_access")
role_access_doc["users"] = ["USER_B"]
role_access_doc["roles"] = ["role:channel-A-role"]
client.add_doc(sg_url,
db=sg_db,
doc=role_access_doc,
auth=admin_session)
elif grant_type == "CHANNEL-TO-ROLE-REST":
# Update the empty_role to have channel "A"
client.update_role(url=sg_admin_url,
db=sg_db,
name="empty_role",
channels=["A"])
elif grant_type == "CHANNEL-TO-ROLE-SYNC":
# Grant empty_role access to channel "A" via sync function
# Grant channel access to role via sync function
access_doc = document.create_doc("channel_grant_to_role")
access_doc["roles"] = ["role:empty_role"]
access_doc["channels"] = ["A"]
client.add_doc(url=sg_url,
db=sg_db,
doc=access_doc,
auth=admin_session,
use_post=True)
else:
pytest.fail("Unsupported grant_type!!!!")
# Block on return of longpoll changes, feed should wake up and return 20 results
changes = changes_task.result()
assert len(changes["results"]) == 20
num_requests = 1
# append _user/doc to the doc scratch pad if a REST grant
if grant_type == "CHANNEL-REST" or grant_type == "ROLE-REST":
ids_and_revs_from_a_docs["_user/USER_B"] = None
# Cross the results off from the 'a_docs' dictionary
for doc in changes["results"]:
del ids_and_revs_from_a_docs[doc["id"]]
# Start looping longpoll changes with limit, cross off changes from dictionary each time one is found
# Since 20 changes should be crossed off already, this should execute 2x.
log_info("Starting looping longpoll changes with limit!")
last_seq = changes["last_seq"]
while True:
if len(ids_and_revs_from_a_docs.keys()) == 0:
log_info("All docs were found! Exiting polling loop")
break
changes = client.get_changes(url=sg_url,
db=sg_db,
since=last_seq,
auth=user_b_session,
limit=20,
timeout=10)
num_requests += 1
# There are more than 2 requests, throw an exception.
if num_requests == 2:
assert len(changes["results"]) == 20
elif num_requests == 3:
# This will be 10 or 11 depending on if the _user/ doc is returned
if grant_type == "CHANNEL-REST" or grant_type == "ROLE-REST":
assert len(changes["results"]) == 11
else:
assert len(changes["results"]) == 10
else:
raise exceptions.ChangesError(
"Looping longpoll should only have to perform 3 requests to get all the changes!!"
)
# Cross the results off from the 'a_docs' dictionary.
# This will blow up in docs duplicate docs are sent to changes
for doc in changes["results"]:
del ids_and_revs_from_a_docs[doc["id"]]
last_seq = changes["last_seq"]
# Shanges after longpoll
zero_results = client.get_changes(url=sg_url,
db=sg_db,
since=last_seq,
auth=user_b_session,
feed="normal")
# Changes should be caught up and there should be no results
assert len(zero_results["results"]) == 0
def test_server_goes_down_rebuild_channels(params_from_base_test_setup):
"""
1. Start with a two node couchbase server cluster
2. Starting adding docs
3. Kill one of the server nodes and signal completion
4. Stop adding docs
5. Verify that that the expected docs are present and in the changes feed.
6. Start server again and add to cluster
"""
cluster_config = params_from_base_test_setup["cluster_config"]
mode = params_from_base_test_setup["mode"]
sg_version = get_sg_version(cluster_config)
if compare_versions(sg_version, '1.5') < 0:
pytest.skip("This test needs multiple URLs in the SG config, not supported by SG < 1.5")
cluster_helper = ClusterKeywords()
sg_conf_name = "sync_gateway_default_functional_tests"
sg_conf_path = sync_gateway_config_path_for_mode(sg_conf_name, mode)
cluster_helper.reset_cluster(cluster_config=cluster_config,
sync_gateway_config=sg_conf_path)
topology = cluster_helper.get_cluster_topology(cluster_config)
admin_sg = topology["sync_gateways"][0]["admin"]
sg_url = topology["sync_gateways"][0]["public"]
coucbase_servers = topology["couchbase_servers"]
cbs_one_url = coucbase_servers[0]
cbs_two_url = coucbase_servers[1]
log_info("Running: 'test_server_goes_down_sanity'")
log_info("cluster_config: {}".format(cluster_config))
log_info("admin_sg: {}".format(admin_sg))
log_info("sg_url: {}".format(sg_url))
log_info("cbs_one_url: {}".format(cbs_one_url))
log_info("cbs_two_url: {}".format(cbs_two_url))
sg_db = "db"
num_docs = 100
admin_user_info = userinfo.UserInfo(
name="admin",
password="******",
channels=["ABC"],
roles=[]
)
seth_user_info = userinfo.UserInfo(
name="seth",
password="******",
channels=["ABC"],
roles=[]
)
client = MobileRestClient()
main_server = couchbaseserver.CouchbaseServer(cbs_one_url)
flakey_server = couchbaseserver.CouchbaseServer(cbs_two_url)
admin_auth = client.create_user(
admin_sg,
sg_db,
admin_user_info.name,
admin_user_info.password,
channels=admin_user_info.channels
)
client.create_user(
admin_sg,
sg_db,
seth_user_info.name,
seth_user_info.password,
channels=seth_user_info.channels
)
seth_session = client.create_session(admin_sg, sg_db, seth_user_info.name)
# allow any user docs to make it to changes
initial_changes = client.get_changes(url=sg_url, db=sg_db, since=0, auth=seth_session)
# push docs from admin
docs = client.add_docs(
url=sg_url,
db=sg_db,
number=num_docs,
id_prefix=None,
channels=admin_user_info.channels,
auth=admin_auth
)
assert len(docs) == num_docs
client.verify_docs_in_changes(url=sg_url, db=sg_db, expected_docs=docs, auth=seth_session)
changes_before_failover = client.get_changes(url=sg_url, db=sg_db, since=initial_changes["last_seq"], auth=seth_session)
assert len(changes_before_failover["results"]) == num_docs
# Stop server via 'service stop'
flakey_server.stop()
start = time.time()
while True:
# Fail tests if all docs do not succeed before timeout
if (time.time() - start) > 60:
# Bring server back up before failing the test
flakey_server.start()
main_server.recover(flakey_server)
main_server.rebalance_in(coucbase_servers, flakey_server)
raise keywords.exceptions.TimeoutError("Failed to rebuild changes")
try:
# Poll until failover happens (~30 second)
client.verify_docs_in_changes(url=sg_url, db=sg_db, expected_docs=docs, auth=seth_session)
# changes requests succeeded, exit loop
break
except requests.exceptions.HTTPError:
# Changes will fail until failover of the down server happens. Wait and try again.
log_info("/db/_changes failed due to server down. Retrying ...")
time.sleep(1)
# Verify no new changes
changes = client.get_changes(
url=sg_url,
db=sg_db,
since=changes_before_failover["last_seq"],
auth=seth_session,
feed="normal"
)
assert len(changes["results"]) == 0
# Check that all changes are intact from initial changes request
changes = client.get_changes(url=sg_url, db=sg_db, since=initial_changes["last_seq"], auth=seth_session)
assert len(changes["results"]) == num_docs
coucbase_servers = topology["couchbase_servers"]
# Test succeeded without timeout, bring server back into topology
flakey_server.start()
main_server.recover(flakey_server)
main_server.rebalance_in(coucbase_servers, flakey_server)
def test_backfill_channels_oneshot_changes(params_from_base_test_setup, sg_conf_name, grant_type):
cluster_config = params_from_base_test_setup["cluster_config"]
topology = params_from_base_test_setup["cluster_topology"]
mode = params_from_base_test_setup["mode"]
sg_url = topology["sync_gateways"][0]["public"]
sg_admin_url = topology["sync_gateways"][0]["admin"]
sg_db = "db"
log_info("grant_type: {}".format(grant_type))
sg_conf = sync_gateway_config_path_for_mode(sg_conf_name, mode)
cluster = Cluster(cluster_config)
cluster.reset(sg_conf)
client = MobileRestClient()
admin_user_info = userinfo.UserInfo("admin", "pass", channels=["A"], roles=[])
user_b_user_info = userinfo.UserInfo("USER_B", "pass", channels=["B"], roles=[])
# Create users / sessions
client.create_user(url=sg_admin_url, db=sg_db,
name=admin_user_info.name, password=admin_user_info.password, channels=admin_user_info.channels)
client.create_user(url=sg_admin_url, db=sg_db,
name=user_b_user_info.name, password=user_b_user_info.password, channels=user_b_user_info.channels)
admin_session = client.create_session(url=sg_admin_url, db=sg_db, name=admin_user_info.name, password=admin_user_info.password)
user_b_session = client.create_session(url=sg_admin_url, db=sg_db, name=user_b_user_info.name, password=user_b_user_info.password)
# Create 50 "A" channel docs
a_docs = client.add_docs(url=sg_url, db=sg_db, number=50, id_prefix=None, auth=admin_session, channels=["A"])
assert len(a_docs) == 50
b_docs = client.add_docs(url=sg_url, db=sg_db, number=1, id_prefix="b_doc", auth=user_b_session, channels=["B"])
assert len(b_docs) == 1
user_doc = {"id": "_user/USER_B", "rev": None}
b_docs.append(user_doc)
# Loop until user_b sees b_doc_0 doc and _user/USER_B doc
client.verify_docs_in_changes(url=sg_url, db=sg_db, expected_docs=b_docs, auth=user_b_session, strict=True)
# Get last_seq for user_b
user_b_changes = client.get_changes(url=sg_url, db=sg_db, since=0, auth=user_b_session, feed="normal")
# Grant access to channel "A"
if grant_type == "CHANNEL-REST":
log_info("Granting user access to channel A via Admin REST user update")
# Grant via update to user in Admin API
client.update_user(url=sg_admin_url, db=sg_db,
name=user_b_user_info.name, channels=["A", "B"])
elif grant_type == "CHANNEL-SYNC":
log_info("Granting user access to channel A sync function access()")
# Grant via access() in sync_function, then id 'channel_access' will trigger an access(doc.users, doc.channels)
access_doc = document.create_doc("channel_access", channels=["A"])
access_doc["users"] = ["USER_B"]
client.add_doc(url=sg_url, db=sg_db, doc=access_doc, auth=admin_session)
elif grant_type == "ROLE-REST":
log_info("Granting user access to channel A via Admin REST role grant")
# Create role with channel A
client.create_role(url=sg_admin_url, db=sg_db, name="channel-A-role", channels=["A"])
client.update_user(url=sg_admin_url, db=sg_db, name="USER_B", roles=["channel-A-role"])
elif grant_type == "ROLE-SYNC":
log_info("Granting user access to channel A via sync function role() grant")
# Create role with channel A
client.create_role(url=sg_admin_url, db=sg_db, name="channel-A-role", channels=["A"])
# Grant via role() in sync_function, then id 'role_access' will trigger an role(doc.users, doc.roles)
role_access_doc = document.create_doc("role_access")
role_access_doc["users"] = ["USER_B"]
role_access_doc["roles"] = ["role:channel-A-role"]
client.add_doc(sg_url, db=sg_db, doc=role_access_doc, auth=admin_session)
else:
pytest.fail("Unsupported grant_type!!!!")
user_b_changes_after_grant = client.get_changes(url=sg_url, db=sg_db,
since=user_b_changes["last_seq"], auth=user_b_session, feed="normal")
# User B shoud have recieved 51 docs (a_docs + 1 _user/USER_B doc) if a REST grant or 50 changes if the grant
# is via the sync function
changes_results = user_b_changes_after_grant["results"]
assert 50 <= len(changes_results) <= 51
# Create a dictionary of id rev pair of all the docs that are not "_user/" docs from changes
ids_and_revs_from_user_changes = {
change["id"]: change["changes"][0]["rev"]
for change in changes_results if not change["id"].startswith("_user/")
}
assert len(ids_and_revs_from_user_changes) == 50
# Create a list of id rev pair of all of the channel A docs
ids_and_revs_from_a_docs = {doc["id"]: doc["rev"] for doc in a_docs}
assert len(ids_and_revs_from_a_docs) == 50
# Check that the changes and the a_docs are identical in id and rev
assert ids_and_revs_from_user_changes == ids_and_revs_from_a_docs
# Get changes from last_seq of the changes request after the grant. There should be no new changes
user_b_changes = client.get_changes(url=sg_url, db=sg_db,
since=user_b_changes_after_grant["last_seq"], auth=user_b_session, feed="normal")
assert len(user_b_changes["results"]) == 0
def test_remove_add_channels_to_doc(params_from_base_test_setup, sg_conf_name):
cluster_config = params_from_base_test_setup["cluster_config"]
topology = params_from_base_test_setup["cluster_topology"]
mode = params_from_base_test_setup["mode"]
sg_url = topology["sync_gateways"][0]["public"]
sg_admin_url = topology["sync_gateways"][0]["admin"]
sg_db = "db"
sg_conf = sync_gateway_config_path_for_mode(sg_conf_name, mode)
cluster = Cluster(cluster_config)
cluster.reset(sg_conf)
client = MobileRestClient()
admin_user_info = userinfo.UserInfo("admin", "pass", channels=["A", "B"], roles=[])
a_user_info = userinfo.UserInfo("a_user", "pass", channels=["A"], roles=[])
admin_user_auth = client.create_user(
url=sg_admin_url,
db=sg_db,
name=admin_user_info.name,
password=admin_user_info.password,
channels=admin_user_info.channels,
)
a_user_auth = client.create_user(
url=sg_admin_url, db=sg_db, name=a_user_info.name, password=a_user_info.password, channels=a_user_info.channels
)
a_docs = client.add_docs(
url=sg_url, db=sg_db, number=50, id_prefix="a_doc", auth=admin_user_auth, channels=admin_user_info.channels
)
# Build dictionay of a_docs
a_docs_id_rev = {doc["id"]: doc["rev"] for doc in a_docs}
assert len(a_docs_id_rev) == 50
# Wait for all docs to show up in changes
client.verify_doc_id_in_changes(sg_url, sg_db, expected_doc_id="_user/a_user", auth=a_user_auth)
client.verify_docs_in_changes(sg_url, sg_db, expected_docs=a_docs, auth=a_user_auth)
# Get changes for 'a_user'
a_user_changes = client.get_changes(url=sg_url, db=sg_db, since=0, auth=a_user_auth, feed="normal")
# 'a_user' should get 50 'a_doc_*' doc and 1 '_user/a_user' doc
assert len(a_user_changes["results"]) == 51
###########################
# Remove Channels from doc
###########################
# Copy a_docs_id_rev to dictionary to scratch off values
remove_docs_scratch_off = a_docs_id_rev.copy()
assert len(remove_docs_scratch_off) == 50
# Use admin user to update the docs to remove 'A' from the channels property on the doc and add 'B'
client.update_docs(url=sg_url, db=sg_db, docs=a_docs, number_updates=1, auth=admin_user_auth, channels=["B"])
# Longpoll loop requires due to the delay that changes take to permeate to the client
changes_timeout = 10
start = time.time()
last_seq = a_user_changes["last_seq"]
while True:
# If take longer than 10 seconds, fail the test
if time.time() - start > changes_timeout:
raise keywords.exceptions.TimeoutException("Could not find all expected docs in changs feed")
# We found everything, exit loop!
if remove_docs_scratch_off == {}:
log_info("All expected docs found to be removed")
break
# Get changes for 'a_user' from last_seq
a_user_changes = client.get_changes(url=sg_url, db=sg_db, since=last_seq, auth=a_user_auth, timeout=10)
assert len(a_user_changes["results"]) > 0
# Loop over changes found and perform the following
# 1. Check that the docs is flagged with 'removed'
# 2. Cross off the doc fromt the the 'remove_docs_scratch_off'
for change in a_user_changes["results"]:
assert change["removed"] == ["A"]
assert change["changes"][0]["rev"].startswith("2-")
# This will blow up if any change is not found in that dictionary
del remove_docs_scratch_off[change["id"]]
# Update last_seq
last_seq = a_user_changes["last_seq"]
# Issue changes request from 'last_seq' and verify that the changes are up to date and returns no results
a_user_changes = client.get_changes(url=sg_url, db=sg_db, since=last_seq, auth=a_user_auth, feed="normal")
assert len(a_user_changes["results"]) == 0
#########################
# Add Channels to doc
#########################
# Copy the a_docs_id_rev dictionary for scratch ovee
add_docs_scratch_off = a_docs_id_rev.copy()
assert len(add_docs_scratch_off) == 50
# Use admin user to update the docs to add ['A'] back to document channels
client.update_docs(url=sg_url, db=sg_db, docs=a_docs, number_updates=1, auth=admin_user_auth, channels=["A"])
# Longpoll loop requires due to the delay that changes take to permeate to the client
changes_timeout = 10
start = time.time()
last_seq = a_user_changes["last_seq"]
while True:
# If take longer than 10 seconds, fail the test
if time.time() - start > changes_timeout:
raise keywords.exceptions.TimeoutException("Could not find all expected docs in changs feed")
# We found everything, exit loop!
if add_docs_scratch_off == {}:
log_info("All expected docs found to be removed")
break
# Get changes for 'a_user' from last_seq
a_user_changes = client.get_changes(url=sg_url, db=sg_db, since=last_seq, auth=a_user_auth, timeout=10)
assert len(a_user_changes["results"]) > 0
# Loop over changes found and perform the following
# 1. Check that the docs has a 3rd gen rev prefix
# 2. Cross off the doc fromt the the 'add_docs_scratch_off'
for change in a_user_changes["results"]:
assert change["changes"][0]["rev"].startswith("3-")
# This will blow up if any change is not found in that dictionary
del add_docs_scratch_off[change["id"]]
# Update last_seq
last_seq = a_user_changes["last_seq"]
# Issue changes request from 'last_seq' and verify that the changes are up to date and returns no results
a_user_changes = client.get_changes(url=sg_url, db=sg_db, since=last_seq, auth=a_user_auth, feed="normal")
assert len(a_user_changes["results"]) == 0
def test_winning_conflict_branch_revisions(params_from_base_test_setup, sg_conf_name):
""" Add winning conflict revisions to the revision tree and ensure
that the changes feed returns the correct revisions
Steps:
- Create a doc ('test_doc')
- Add 5 revs to 'test_doc'
- POST _changes, assert rev starts with "6-" from 0, store "last_seq_1"
- Create a conflict off first revision ("2-foo") (POST docs, new_edits == false)
- Append 5 revisions to the conflicting branch
(3-foo with 2-foo as parent, 4-foo with 3-foo as parent ... 7-foo with 6-foo as parent)
- GET 'test_doc' and verify that the rev is '7-foo'
- POST _changes, assert returns 7-foo
"""
cluster_config = params_from_base_test_setup["cluster_config"]
topology = params_from_base_test_setup["cluster_topology"]
mode = params_from_base_test_setup["mode"]
sg_url = topology["sync_gateways"][0]["public"]
sg_admin_url = topology["sync_gateways"][0]["admin"]
sg_db = "db"
sg_conf = sync_gateway_config_path_for_mode(sg_conf_name, mode)
c = cluster.Cluster(cluster_config)
c.reset(sg_conf)
client = MobileRestClient()
seth_user_info = userinfo.UserInfo(
name="seth",
password="******",
channels=["NATGEO"],
roles=[]
)
seth_auth = client.create_user(
url=sg_admin_url,
db=sg_db,
name=seth_user_info.name,
password=seth_user_info.password,
channels=seth_user_info.channels
)
test_doc_body = document.create_doc(doc_id="test_doc", channels=seth_user_info.channels)
rev_gen_1_doc = client.add_doc(url=sg_url, db=sg_db, doc=test_doc_body, auth=seth_auth)
rev_gen_6_doc = client.update_doc(url=sg_url, db=sg_db, doc_id=rev_gen_1_doc["id"], number_updates=5, auth=seth_auth)
assert rev_gen_6_doc["rev"].startswith("6-")
# Wait until doc shows up in changes feed
last_seq = 0
start = time.time()
while True:
if time.time() - start > keywords.constants.CLIENT_REQUEST_TIMEOUT:
raise keywords.exceptions.TimeoutError("Wait for Replication Status Idle: TIMEOUT")
changes_1 = client.get_changes(url=sg_url, db=sg_db, since=last_seq, auth=seth_auth, skip_user_docs=True)
last_seq = changes_1["last_seq"]
if len(changes_1["results"]) > 0 and changes_1["results"][0]["changes"][0]["rev"].startswith("6-"):
break
assert len(changes_1["results"]) == 1
assert changes_1["results"][0]["id"] == "test_doc"
assert changes_1["results"][0]["changes"][0]["rev"].startswith("6-")
# Create a conflict off of rev one
rev_gen_1_doc_conflict = client.add_conflict(
url=sg_url,
db=sg_db,
doc_id=rev_gen_1_doc["id"],
parent_revisions=rev_gen_1_doc["rev"],
new_revision="2-foo",
auth=seth_auth
)
# Update the conflicting branch 5x
rev_gen = 3
for _ in range(5):
rev_gen_1_doc_conflict = client.add_conflict(
url=sg_url,
db=sg_db,
doc_id=rev_gen_1_doc["id"],
parent_revisions=rev_gen_1_doc_conflict["rev"],
new_revision="{}-foo".format(rev_gen),
auth=seth_auth
)
rev_gen += 1
# Wait until doc shows up in changes feed from last_seq from where last changes loop from above left off
start = time.time()
while True:
if time.time() - start > keywords.constants.CLIENT_REQUEST_TIMEOUT:
raise keywords.exceptions.TimeoutError("Wait for Replication Status Idle: TIMEOUT")
changes_2 = client.get_changes(url=sg_url, db=sg_db, since=last_seq, auth=seth_auth)
last_seq = changes_2["last_seq"]
if len(changes_2["results"]) > 0:
break
# Verify that the the "7-foo" rev is return on the changes feed
assert len(changes_2["results"]) == 1
assert changes_2["results"][0]["id"] == "test_doc"
assert changes_2["results"][0]["changes"][0]["rev"] == "7-foo"
def test_view_backfill_for_deletes(params_from_base_test_setup, sg_conf_name,
validate_changes_before_restart):
"""
Scenario:
1. Write a bunch of docs
2. Delete 1/2
3. Restart Sync Gateway
4. Issue _changes, assert view backfills docs and delete notifications
"""
num_docs = 1000
sg_db = 'db'
cluster_conf = params_from_base_test_setup['cluster_config']
cluster_topology = params_from_base_test_setup['cluster_topology']
mode = params_from_base_test_setup['mode']
sg_conf = sync_gateway_config_path_for_mode(sg_conf_name, mode)
sg_admin_url = cluster_topology['sync_gateways'][0]['admin']
sg_url = cluster_topology['sync_gateways'][0]['public']
cbs_url = cluster_topology['couchbase_servers'][0]
log_info('sg_conf: {}'.format(sg_conf))
log_info('sg_admin_url: {}'.format(sg_admin_url))
log_info('sg_url: {}'.format(sg_url))
log_info('cbs_url: {}'.format(cbs_url))
log_info('validate_changes_before_restart: {}'.format(
validate_changes_before_restart))
cluster = Cluster(config=cluster_conf)
cluster.reset(sg_config_path=sg_conf)
# Create clients
sg_client = MobileRestClient()
# Create user / session
seth_user_info = UserInfo(name='seth',
password='******',
channels=['NASA', 'NATGEO'],
roles=[])
sg_client.create_user(url=sg_admin_url,
db=sg_db,
name=seth_user_info.name,
password=seth_user_info.password,
channels=seth_user_info.channels)
seth_auth = sg_client.create_session(url=sg_admin_url,
db=sg_db,
name=seth_user_info.name,
password=seth_user_info.password)
# Add 'num_docs' to Sync Gateway
doc_bodies = document.create_docs('test_doc',
number=num_docs,
channels=seth_user_info.channels)
bulk_resp = sg_client.add_bulk_docs(url=sg_url,
db=sg_db,
docs=doc_bodies,
auth=seth_auth)
assert len(bulk_resp) == num_docs
# Delete half of the docs randomly
deleted_docs = []
for _ in range(num_docs / 2):
random_doc = random.choice(bulk_resp)
deleted_doc = sg_client.delete_doc(url=sg_url,
db=sg_db,
doc_id=random_doc['id'],
rev=random_doc['rev'],
auth=seth_auth)
deleted_docs.append(deleted_doc)
bulk_resp.remove(random_doc)
log_info('Number of docs deleted: {}'.format(len(deleted_docs)))
all_docs = bulk_resp + deleted_docs
log_info('Number of docs to look for in changes: {}'.format(len(all_docs)))
# This test will check changes before and after SG restart if
# validate_changes_before_restart == True
# If it is not set to True, only build the changes after restart
if validate_changes_before_restart:
# Verify deletions and inital docs show up in changes feed
sg_client.verify_docs_in_changes(url=sg_url,
db=sg_db,
expected_docs=all_docs,
auth=seth_auth)
changes = sg_client.get_changes(url=sg_url,
db=sg_db,
since=0,
auth=seth_auth)
# All docs should show up + _user doc
assert len(changes['results']) == num_docs + 1
deleted_doc_ids = [doc['id'] for doc in deleted_docs]
assert len(deleted_doc_ids) == num_docs / 2
deleted_docs_in_changes = [
change['id'] for change in changes['results']
if 'deleted' in change and change['deleted']
]
assert len(deleted_docs_in_changes) == num_docs / 2
# All deleted docs should show up in the changes feed
for doc_id in deleted_docs_in_changes:
assert doc_id in deleted_doc_ids
deleted_doc_ids.remove(doc_id)
assert len(deleted_doc_ids) == 0
# Restart Sync Gateway
sg_controller = SyncGateway()
sg_controller.stop_sync_gateways(url=sg_url, cluster_config=cluster_conf)
sg_controller.start_sync_gateways(url=sg_url,
cluster_config=cluster_conf,
config=sg_conf)
# Verify deletions and inital docs show up in changes feed
sg_client.verify_docs_in_changes(url=sg_url,
db=sg_db,
expected_docs=all_docs,
auth=seth_auth)
changes = sg_client.get_changes(url=sg_url,
db=sg_db,
since=0,
auth=seth_auth)
# All docs should show up + _user doc
assert len(changes['results']) == num_docs + 1
deleted_doc_ids = [doc['id'] for doc in deleted_docs]
assert len(deleted_doc_ids) == num_docs / 2
deleted_docs_in_changes = [
change['id'] for change in changes['results']
if 'deleted' in change and change['deleted']
]
assert len(deleted_docs_in_changes) == num_docs / 2
# All deleted docs should show up in th changes feed
for doc_id in deleted_docs_in_changes:
assert doc_id in deleted_doc_ids
deleted_doc_ids.remove(doc_id)
assert len(deleted_doc_ids) == 0
def test_non_winning_revisions(params_from_base_test_setup, sg_conf_name):
""" Add non-winning revisions to the revision tree and ensure
that the changes feed returns the correct revisions
Steps:
- Add a doc
- Add 5 revs
- changes, assert rev starts with "6-" from 0, store "last_seq_1"
- Create a conflict off first revision ("2-foo") (POST docs, new_edits == false)
- changes, assert rev starts with "6-" from "last_seq_1", store "last_seq_2"
- changes, assert rev starts with "6-" from 0
- Add a "3-foo" rev with rev "2-foo" as parent
- changes, assert rev starts with "6-" from "last_seq_2", store "last_seq_3"
- changes, assert rev starts with "6-" from 0
- add tombstone rev as child of "6-" i.e. issue delete on ("6-")
- changes, assert rev starts with "3-foo" from "last_seq_3"
- changes, assert rev starts with "3-foo" from 0
"""
cluster_config = params_from_base_test_setup["cluster_config"]
topology = params_from_base_test_setup["cluster_topology"]
mode = params_from_base_test_setup["mode"]
no_conflicts_enabled = params_from_base_test_setup["no_conflicts_enabled"]
if no_conflicts_enabled:
pytest.skip(
'--no-conflicts is enabled, this test needs to create conflicts, so skipping the test'
)
sg_url = topology["sync_gateways"][0]["public"]
sg_admin_url = topology["sync_gateways"][0]["admin"]
sg_db = "db"
sg_conf = sync_gateway_config_path_for_mode(sg_conf_name, mode)
c = cluster.Cluster(cluster_config)
c.reset(sg_conf)
client = MobileRestClient()
seth_user_info = userinfo.UserInfo(name="seth",
password="******",
channels=["NATGEO"],
roles=[])
seth_auth = client.create_user(url=sg_admin_url,
db=sg_db,
name=seth_user_info.name,
password=seth_user_info.password,
channels=seth_user_info.channels)
test_doc_body = document.create_doc(doc_id="test_doc",
channels=seth_user_info.channels)
rev_gen_1_doc = client.add_doc(url=sg_url,
db=sg_db,
doc=test_doc_body,
auth=seth_auth)
rev_gen_6_doc = client.update_doc(url=sg_url,
db=sg_db,
doc_id=rev_gen_1_doc["id"],
number_updates=5,
auth=seth_auth)
assert rev_gen_6_doc["rev"].startswith("6-")
# Get changes until rev generation 6 document shows up
start = time.time()
last_seq = 0
while True:
if time.time() - start > keywords.constants.CLIENT_REQUEST_TIMEOUT:
raise keywords.exceptions.TimeoutError(
"Wait for Replication Status Idle: TIMEOUT")
changes_1 = client.get_changes(url=sg_url,
db=sg_db,
since=last_seq,
auth=seth_auth,
skip_user_docs=True)
last_seq = changes_1["last_seq"]
# break when expected rev shows up in changes feed
if changes_1["results"] and changes_1["results"][0]["changes"][0][
"rev"].startswith("6-"):
break
assert len(changes_1["results"]) == 1
assert changes_1["results"][0]["id"] == "test_doc"
assert changes_1["results"][0]["changes"][0]["rev"].startswith("6-")
# Create a conflict off of rev one
rev_gen_2_doc_conflict = client.add_conflict(
url=sg_url,
db=sg_db,
doc_id=rev_gen_1_doc["id"],
parent_revisions=rev_gen_1_doc["rev"],
new_revision="2-foo",
auth=seth_auth)
assert rev_gen_2_doc_conflict["id"] == "test_doc"
assert rev_gen_2_doc_conflict["rev"] == "2-foo"
# Issue changes since changes_1 last_seq above
changes_2 = client.get_changes(url=sg_url,
db=sg_db,
since=changes_1["last_seq"],
auth=seth_auth)
assert len(changes_2["results"]) == 1
assert changes_2["results"][0]["id"] == "test_doc"
assert changes_2["results"][0]["changes"][0]["rev"].startswith("6-")
# Issue changes since 0, strip user doc and make sure the doc is still the '6-' rev
changes_from_0_one = client.get_changes(url=sg_url,
db=sg_db,
since=0,
auth=seth_auth,
skip_user_docs=True)
assert len(changes_from_0_one["results"]) == 1
assert changes_from_0_one["results"][0]["id"] == "test_doc"
assert changes_from_0_one["results"][0]["changes"][0]["rev"].startswith(
"6-")
# Create a 3-foo rev with 2-foo as the parent
rev_gen_3_doc_conflict = client.add_conflict(
url=sg_url,
db=sg_db,
doc_id=rev_gen_2_doc_conflict["id"],
parent_revisions=rev_gen_2_doc_conflict["rev"],
new_revision="3-foo",
auth=seth_auth)
assert rev_gen_3_doc_conflict["id"] == "test_doc"
assert rev_gen_3_doc_conflict["rev"] == "3-foo"
# Issue changes since changes_2 last_seq above
changes_3 = client.get_changes(url=sg_url,
db=sg_db,
since=changes_2["last_seq"],
auth=seth_auth)
assert len(changes_3["results"]) == 1
assert changes_3["results"][0]["id"] == "test_doc"
assert changes_3["results"][0]["changes"][0]["rev"].startswith("6-")
# Issue changes since 0, strip user doc and make sure the doc is still the '6-' rev
changes_from_0_two = client.get_changes(url=sg_url,
db=sg_db,
since=0,
auth=seth_auth,
skip_user_docs=True)
assert len(changes_from_0_two["results"]) == 1
assert changes_from_0_two["results"][0]["id"] == "test_doc"
assert changes_from_0_two["results"][0]["changes"][0]["rev"].startswith(
"6-")
# Delete test_doc at rev 6-*
client.delete_doc(url=sg_url,
db=sg_db,
doc_id=rev_gen_6_doc["id"],
rev=rev_gen_6_doc["rev"],
auth=seth_auth)
# Issue changes since changes_3 last_seq above
changes_4 = client.get_changes(url=sg_url,
db=sg_db,
since=changes_3["last_seq"],
auth=seth_auth)
assert len(changes_4["results"]) == 1
assert changes_4["results"][0]["id"] == "test_doc"
assert changes_4["results"][0]["changes"][0]["rev"] == "3-foo"
# Issue a oneshot changes since changes_4 last_seq and assert no results are returned
changes_5 = client.get_changes(url=sg_url,
db=sg_db,
since=changes_4["last_seq"],
feed="normal",
auth=seth_auth)
assert len(changes_5["results"]) == 0
def test_winning_conflict_branch_revisions(params_from_base_test_setup,
sg_conf_name):
""" Add winning conflict revisions to the revision tree and ensure
that the changes feed returns the correct revisions
Steps:
- Add a doc ('test_doc')
- Add 5 revs to 'test_doc'
- POST _changes, assert rev starts with "6-" from 0, store "last_seq_1"
- Create a conflict off first revision ("2-foo") (POST docs, new_edits == false)
- Append 5 revisions to the conflicting branch
(3-foo with 2-foo as parent, 4-foo with 3-foo as parent ... 7-foo with 6-foo as parent)
- GET 'test_doc' and verify that the rev is '7-foo'
- POST _changes, assert returns 7-foo
"""
cluster_config = params_from_base_test_setup["cluster_config"]
topology = params_from_base_test_setup["cluster_topology"]
mode = params_from_base_test_setup["mode"]
no_conflicts_enabled = params_from_base_test_setup["no_conflicts_enabled"]
if no_conflicts_enabled:
pytest.skip(
'--no-conflicts is enabled, this test needs to create conflicts, so skipping the test'
)
sg_url = topology["sync_gateways"][0]["public"]
sg_admin_url = topology["sync_gateways"][0]["admin"]
sg_db = "db"
sg_conf = sync_gateway_config_path_for_mode(sg_conf_name, mode)
c = cluster.Cluster(cluster_config)
c.reset(sg_conf)
client = MobileRestClient()
seth_user_info = userinfo.UserInfo(name="seth",
password="******",
channels=["NATGEO"],
roles=[])
seth_auth = client.create_user(url=sg_admin_url,
db=sg_db,
name=seth_user_info.name,
password=seth_user_info.password,
channels=seth_user_info.channels)
test_doc_body = document.create_doc(doc_id="test_doc",
channels=seth_user_info.channels)
rev_gen_1_doc = client.add_doc(url=sg_url,
db=sg_db,
doc=test_doc_body,
auth=seth_auth)
rev_gen_6_doc = client.update_doc(url=sg_url,
db=sg_db,
doc_id=rev_gen_1_doc["id"],
number_updates=5,
auth=seth_auth)
assert rev_gen_6_doc["rev"].startswith("6-")
# Wait until doc shows up in changes feed
last_seq = 0
start = time.time()
while True:
if time.time() - start > keywords.constants.CLIENT_REQUEST_TIMEOUT:
raise keywords.exceptions.TimeoutError(
"Wait for Replication Status Idle: TIMEOUT")
changes_1 = client.get_changes(url=sg_url,
db=sg_db,
since=last_seq,
auth=seth_auth,
skip_user_docs=True)
last_seq = changes_1["last_seq"]
if len(changes_1["results"]) > 0 and changes_1["results"][0][
"changes"][0]["rev"].startswith("6-"):
break
assert len(changes_1["results"]) == 1
assert changes_1["results"][0]["id"] == "test_doc"
assert changes_1["results"][0]["changes"][0]["rev"].startswith("6-")
# Create a conflict off of rev one
rev_gen_1_doc_conflict = client.add_conflict(
url=sg_url,
db=sg_db,
doc_id=rev_gen_1_doc["id"],
parent_revisions=rev_gen_1_doc["rev"],
new_revision="2-foo",
auth=seth_auth)
# Update the conflicting branch 5x
rev_gen = 3
for _ in range(5):
rev_gen_1_doc_conflict = client.add_conflict(
url=sg_url,
db=sg_db,
doc_id=rev_gen_1_doc["id"],
parent_revisions=rev_gen_1_doc_conflict["rev"],
new_revision="{}-foo".format(rev_gen),
auth=seth_auth)
rev_gen += 1
# Wait until doc shows up in changes feed from last_seq from where last changes loop from above left off
start = time.time()
while True:
if time.time() - start > keywords.constants.CLIENT_REQUEST_TIMEOUT:
raise keywords.exceptions.TimeoutError(
"Wait for Replication Status Idle: TIMEOUT")
changes_2 = client.get_changes(url=sg_url,
db=sg_db,
since=last_seq,
auth=seth_auth)
last_seq = changes_2["last_seq"]
if changes_2["results"][0]["changes"][0]["rev"] == "7-foo" and len(
changes_2["results"]) > 0:
break
# Verify that the the "7-foo" rev is return on the changes feed
assert len(changes_2["results"]) == 1
assert changes_2["results"][0]["id"] == "test_doc"
assert changes_2["results"][0]["changes"][0]["rev"] == "7-foo"
def test_server_goes_down_rebuild_channels(params_from_base_test_setup):
"""
1. Start with a two node couchbase server cluster
2. Starting adding docs
3. Kill one of the server nodes and signal completion
4. Stop adding docs
5. Verify that that the expected docs are present and in the changes feed.
6. Start server again and add to cluster
"""
cluster_config = params_from_base_test_setup["cluster_config"]
mode = params_from_base_test_setup["mode"]
cluster_helper = ClusterKeywords()
sg_conf_name = "sync_gateway_default_functional_tests"
sg_conf_path = sync_gateway_config_path_for_mode(sg_conf_name, mode)
cluster_helper.reset_cluster(cluster_config=cluster_config,
sync_gateway_config=sg_conf_path)
topology = cluster_helper.get_cluster_topology(cluster_config)
admin_sg = topology["sync_gateways"][0]["admin"]
sg_url = topology["sync_gateways"][0]["public"]
coucbase_servers = topology["couchbase_servers"]
cbs_one_url = coucbase_servers[0]
cbs_two_url = coucbase_servers[1]
log_info("Running: 'test_server_goes_down_sanity'")
log_info("cluster_config: {}".format(cluster_config))
log_info("admin_sg: {}".format(admin_sg))
log_info("sg_url: {}".format(sg_url))
log_info("cbs_one_url: {}".format(cbs_one_url))
log_info("cbs_two_url: {}".format(cbs_two_url))
sg_db = "db"
num_docs = 100
admin_user_info = userinfo.UserInfo(
name="admin",
password="******",
channels=["ABC"],
roles=[]
)
seth_user_info = userinfo.UserInfo(
name="seth",
password="******",
channels=["ABC"],
roles=[]
)
client = MobileRestClient()
main_server = CouchbaseServer(cbs_one_url)
flakey_server = CouchbaseServer(cbs_two_url)
admin_auth = client.create_user(
admin_sg,
sg_db,
admin_user_info.name,
admin_user_info.password,
channels=admin_user_info.channels
)
client.create_user(
admin_sg,
sg_db,
seth_user_info.name,
seth_user_info.password,
channels=seth_user_info.channels
)
seth_session = client.create_session(admin_sg, sg_db, seth_user_info.name)
# allow any user docs to make it to changes
initial_changes = client.get_changes(url=sg_url, db=sg_db, since=0, auth=seth_session)
# push docs from admin
docs = client.add_docs(
url=sg_url,
db=sg_db,
number=num_docs,
id_prefix=None,
channels=admin_user_info.channels,
auth=admin_auth
)
assert len(docs) == num_docs
client.verify_docs_in_changes(url=sg_url, db=sg_db, expected_docs=docs, auth=seth_session)
changes_before_failover = client.get_changes(url=sg_url, db=sg_db, since=initial_changes["last_seq"], auth=seth_session)
assert len(changes_before_failover["results"]) == num_docs
# Stop server via 'service stop'
flakey_server.stop()
start = time.time()
while True:
# Fail tests if all docs do not succeed before timeout
if (time.time() - start) > 60:
# Bring server back up before failing the test
flakey_server.start()
main_server.recover(flakey_server)
main_server.rebalance_in(coucbase_servers, flakey_server)
raise keywords.exceptions.TimeoutError("Failed to rebuild changes")
try:
# Poll until failover happens (~30 second)
client.verify_docs_in_changes(url=sg_url, db=sg_db, expected_docs=docs, auth=seth_session)
# changes requests succeeded, exit loop
break
except requests.exceptions.HTTPError:
# Changes will fail until failover of the down server happens. Wait and try again.
log_info("/db/_changes failed due to server down. Retrying ...")
time.sleep(1)
# Verify no new changes
changes = client.get_changes(
url=sg_url,
db=sg_db,
since=changes_before_failover["last_seq"],
auth=seth_session,
feed="normal"
)
assert len(changes["results"]) == 0
# Check that all changes are intact from initial changes request
changes = client.get_changes(url=sg_url, db=sg_db, since=initial_changes["last_seq"], auth=seth_session)
assert len(changes["results"]) == num_docs
coucbase_servers = topology["couchbase_servers"]
# Test succeeded without timeout, bring server back into topology
flakey_server.start()
main_server.recover(flakey_server)
main_server.rebalance_in(coucbase_servers, flakey_server)
def test_longpoll_awaken_roles(params_from_base_test_setup, sg_conf_name):
cluster_conf = params_from_base_test_setup["cluster_config"]
cluster_topology = params_from_base_test_setup["cluster_topology"]
mode = params_from_base_test_setup["mode"]
sg_conf = sync_gateway_config_path_for_mode(sg_conf_name, mode)
sg_admin_url = cluster_topology["sync_gateways"][0]["admin"]
sg_url = cluster_topology["sync_gateways"][0]["public"]
log_info("sg_conf: {}".format(sg_conf))
log_info("sg_admin_url: {}".format(sg_admin_url))
log_info("sg_url: {}".format(sg_url))
cluster = Cluster(config=cluster_conf)
cluster.reset(sg_config_path=sg_conf)
admin_role = "admin_role"
admin_channel = "admin_channel"
admin_user_info = userinfo.UserInfo(name="admin", password="******", channels=[], roles=[admin_role])
adam_user_info = userinfo.UserInfo(name="adam", password="******", channels=[], roles=[])
traun_user_info = userinfo.UserInfo(name="traun", password="******", channels=[], roles=[])
andy_user_info = userinfo.UserInfo(name="andy", password="******", channels=[], roles=[])
sg_db = "db"
client = MobileRestClient()
# Create a role on sync_gateway
client.create_role(url=sg_admin_url, db=sg_db, name=admin_role, channels=[admin_channel])
# Create users with no channels or roles
admin_auth = client.create_user(url=sg_admin_url, db=sg_db,
name=admin_user_info.name, password=admin_user_info.password, roles=[admin_role])
adam_auth = client.create_user(url=sg_admin_url, db=sg_db,
name=adam_user_info.name, password=adam_user_info.password)
traun_auth = client.create_user(url=sg_admin_url, db=sg_db,
name=traun_user_info.name, password=traun_user_info.password)
andy_auth = client.create_user(url=sg_admin_url, db=sg_db,
name=andy_user_info.name, password=andy_user_info.password)
################################
# change feed wakes for role add
################################
# Get starting sequence of docs, use the last seq to progress past any _user docs.
adam_changes = client.get_changes(url=sg_url, db=sg_db, since=0, feed="normal", auth=adam_auth)
traun_changes = client.get_changes(url=sg_url, db=sg_db, since=0, feed="normal", auth=traun_auth)
andy_changes = client.get_changes(url=sg_url, db=sg_db, since=0, feed="normal", auth=andy_auth)
# Add doc with channel associated with the admin role
admin_doc = client.add_docs(url=sg_url, db=sg_db, number=1, id_prefix="admin_doc", auth=admin_auth, channels=[admin_channel])
client.verify_docs_in_changes(url=sg_url, db=sg_db, expected_docs=admin_doc, auth=admin_auth)
with concurrent.futures.ProcessPoolExecutor() as ex:
# Start changes feed for 3 users from latest last_seq
adam_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=adam_changes["last_seq"], timeout=10, auth=adam_auth)
traun_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=traun_changes["last_seq"], timeout=10, auth=traun_auth)
andy_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=andy_changes["last_seq"], timeout=10, auth=andy_auth)
# Wait for changes feed to notice there are no changes and enter wait. 2 seconds should be more than enough
time.sleep(2)
# Make sure the changes future is still running and has not exited due to any new changes, the feed should be caught up
# and waiting
assert not adam_changes_task.done()
assert not traun_changes_task.done()
assert not andy_changes_task.done()
adam_auth = client.update_user(url=sg_admin_url, db=sg_db,
name=adam_user_info.name, password=adam_user_info.password, roles=[admin_role])
traun_auth = client.update_user(url=sg_admin_url, db=sg_db,
name=traun_user_info.name, password=traun_user_info.password, roles=[admin_role])
andy_auth = client.update_user(url=sg_admin_url, db=sg_db,
name=andy_user_info.name, password=andy_user_info.password, roles=[admin_role])
adam_changes = adam_changes_task.result()
assert 1 <= len(adam_changes["results"]) <= 2
assert adam_changes["results"][0]["id"] == "admin_doc_0" or adam_changes["results"][0]["id"] == "_user/adam"
traun_changes = traun_changes_task.result()
assert 1 <= len(traun_changes["results"]) <= 2
assert traun_changes["results"][0]["id"] == "admin_doc_0" or traun_changes["results"][0]["id"] == "_user/traun"
andy_changes = andy_changes_task.result()
assert 1 <= len(andy_changes["results"]) <= 2
assert andy_changes["results"][0]["id"] == "admin_doc_0" or andy_changes["results"][0]["id"] == "_user/andy"
# Check that the user docs all show up in changes feed
client.verify_doc_id_in_changes(url=sg_url, db=sg_db, expected_doc_id="_user/adam", auth=adam_auth)
client.verify_doc_id_in_changes(url=sg_url, db=sg_db, expected_doc_id="_user/traun", auth=traun_auth)
client.verify_doc_id_in_changes(url=sg_url, db=sg_db, expected_doc_id="_user/andy", auth=andy_auth)
# Check that the admin doc made it to all the changes feeds
client.verify_docs_in_changes(url=sg_url, db=sg_db, expected_docs=admin_doc, auth=adam_auth)
client.verify_docs_in_changes(url=sg_url, db=sg_db, expected_docs=admin_doc, auth=traun_auth)
client.verify_docs_in_changes(url=sg_url, db=sg_db, expected_docs=admin_doc, auth=andy_auth)
# At this point, each user should have a changes feed that is caught up for the next section
###########################################
# change feed wakes for channel add to role
###########################################
abc_channel = "ABC"
abc_pusher_info = userinfo.UserInfo(name="abc_pusher", password="******", channels=[abc_channel], roles=[])
abc_pusher_auth = client.create_user(url=sg_admin_url, db=sg_db, name=abc_pusher_info.name,
password=abc_pusher_info.password, channels=abc_pusher_info.channels)
# Add doc with ABC channel
client.add_docs(url=sg_url, db=sg_db, number=1, id_prefix="abc_doc", auth=abc_pusher_auth, channels=[abc_channel])
# Get latest last_seq for next test section
adam_changes = client.get_changes(url=sg_url, db=sg_db, since=0, feed="normal", auth=adam_auth)
traun_changes = client.get_changes(url=sg_url, db=sg_db, since=0, feed="normal", auth=traun_auth)
andy_changes = client.get_changes(url=sg_url, db=sg_db, since=0, feed="normal", auth=andy_auth)
with concurrent.futures.ProcessPoolExecutor() as ex:
# Start changes feed for 3 users from latest last_seq
adam_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=adam_changes["last_seq"], timeout=10, auth=adam_auth)
traun_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=traun_changes["last_seq"], timeout=10, auth=traun_auth)
andy_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=andy_changes["last_seq"], timeout=10, auth=andy_auth)
# Wait for changes feed to notice there are no changes and enter wait. 2 seconds should be more than enough
time.sleep(2)
# Make sure the changes future is still running and has not exited due to any new changes, the feed should be caught up
# and waiting
assert not adam_changes_task.done()
assert not traun_changes_task.done()
assert not andy_changes_task.done()
# Update admin role to include ABC channel
# Since adam, traun, and andy are assigned to that role, they should wake up and get the 'abc_pusher_0' doc
client.update_role(url=sg_admin_url, db=sg_db, name=admin_role, channels=[admin_channel, abc_channel])
adam_changes = adam_changes_task.result()
assert len(adam_changes["results"]) == 1
assert adam_changes["results"][0]["id"] == "abc_doc_0"
traun_changes = traun_changes_task.result()
assert len(traun_changes["results"]) == 1
assert traun_changes["results"][0]["id"] == "abc_doc_0"
andy_changes = adam_changes_task.result()
assert len(andy_changes["results"]) == 1
assert andy_changes["results"][0]["id"] == "abc_doc_0"
def test_non_winning_revisions(params_from_base_test_setup, sg_conf_name):
""" Add non-winning revisions to the revision tree and ensure
that the changes feed returns the correct revisions
Steps:
- Create a doc
- Add 5 revs
- changes, assert rev starts with "6-" from 0, store "last_seq_1"
- Create a conflict off first revision ("2-foo") (POST docs, new_edits == false)
- changes, assert rev starts with "6-" from "last_seq_1", store "last_seq_2"
- changes, assert rev starts with "6-" from 0
- Add a "3-foo" rev with rev "2-foo" as parent
- changes, assert rev starts with "6-" from "last_seq_2", store "last_seq_3"
- changes, assert rev starts with "6-" from 0
- add tombstone rev as child of "6-" i.e. issue delete on ("6-")
- changes, assert rev starts with "3-foo" from "last_seq_3"
- changes, assert rev starts with "3-foo" from 0
"""
cluster_config = params_from_base_test_setup["cluster_config"]
topology = params_from_base_test_setup["cluster_topology"]
mode = params_from_base_test_setup["mode"]
sg_url = topology["sync_gateways"][0]["public"]
sg_admin_url = topology["sync_gateways"][0]["admin"]
sg_db = "db"
sg_conf = sync_gateway_config_path_for_mode(sg_conf_name, mode)
c = cluster.Cluster(cluster_config)
c.reset(sg_conf)
client = MobileRestClient()
seth_user_info = userinfo.UserInfo(
name="seth",
password="******",
channels=["NATGEO"],
roles=[]
)
seth_auth = client.create_user(
url=sg_admin_url,
db=sg_db,
name=seth_user_info.name,
password=seth_user_info.password,
channels=seth_user_info.channels
)
test_doc_body = document.create_doc(doc_id="test_doc", channels=seth_user_info.channels)
rev_gen_1_doc = client.add_doc(url=sg_url, db=sg_db, doc=test_doc_body, auth=seth_auth)
rev_gen_6_doc = client.update_doc(url=sg_url, db=sg_db, doc_id=rev_gen_1_doc["id"], number_updates=5, auth=seth_auth)
assert rev_gen_6_doc["rev"].startswith("6-")
# Get changes until rev generation 6 document shows up
start = time.time()
last_seq = 0
while True:
if time.time() - start > keywords.constants.CLIENT_REQUEST_TIMEOUT:
raise keywords.exceptions.TimeoutError("Wait for Replication Status Idle: TIMEOUT")
changes_1 = client.get_changes(url=sg_url, db=sg_db, since=last_seq, auth=seth_auth, skip_user_docs=True)
last_seq = changes_1["last_seq"]
# break when expected rev shows up in changes feed
if changes_1["results"] and changes_1["results"][0]["changes"][0]["rev"].startswith("6-"):
break
assert len(changes_1["results"]) == 1
assert changes_1["results"][0]["id"] == "test_doc"
assert changes_1["results"][0]["changes"][0]["rev"].startswith("6-")
# Create a conflict off of rev one
rev_gen_2_doc_conflict = client.add_conflict(
url=sg_url,
db=sg_db,
doc_id=rev_gen_1_doc["id"],
parent_revisions=rev_gen_1_doc["rev"],
new_revision="2-foo",
auth=seth_auth
)
assert rev_gen_2_doc_conflict["id"] == "test_doc"
assert rev_gen_2_doc_conflict["rev"] == "2-foo"
# Issue changes since changes_1 last_seq above
changes_2 = client.get_changes(url=sg_url, db=sg_db, since=changes_1["last_seq"], auth=seth_auth)
assert len(changes_2["results"]) == 1
assert changes_2["results"][0]["id"] == "test_doc"
assert changes_2["results"][0]["changes"][0]["rev"].startswith("6-")
# Issue changes since 0, strip user doc and make sure the doc is still the '6-' rev
changes_from_0_one = client.get_changes(url=sg_url, db=sg_db, since=0, auth=seth_auth, skip_user_docs=True)
assert len(changes_from_0_one["results"]) == 1
assert changes_from_0_one["results"][0]["id"] == "test_doc"
assert changes_from_0_one["results"][0]["changes"][0]["rev"].startswith("6-")
# Create a 3-foo rev with 2-foo as the parent
rev_gen_3_doc_conflict = client.add_conflict(
url=sg_url,
db=sg_db,
doc_id=rev_gen_2_doc_conflict["id"],
parent_revisions=rev_gen_2_doc_conflict["rev"],
new_revision="3-foo",
auth=seth_auth
)
assert rev_gen_3_doc_conflict["id"] == "test_doc"
assert rev_gen_3_doc_conflict["rev"] == "3-foo"
# Issue changes since changes_2 last_seq above
changes_3 = client.get_changes(url=sg_url, db=sg_db, since=changes_2["last_seq"], auth=seth_auth)
assert len(changes_3["results"]) == 1
assert changes_3["results"][0]["id"] == "test_doc"
assert changes_3["results"][0]["changes"][0]["rev"].startswith("6-")
# Issue changes since 0, strip user doc and make sure the doc is still the '6-' rev
changes_from_0_two = client.get_changes(url=sg_url, db=sg_db, since=0, auth=seth_auth, skip_user_docs=True)
assert len(changes_from_0_two["results"]) == 1
assert changes_from_0_two["results"][0]["id"] == "test_doc"
assert changes_from_0_two["results"][0]["changes"][0]["rev"].startswith("6-")
# Delete test_doc at rev 6-*
client.delete_doc(url=sg_url, db=sg_db, doc_id=rev_gen_6_doc["id"], rev=rev_gen_6_doc["rev"], auth=seth_auth)
# Issue changes since changes_3 last_seq above
changes_4 = client.get_changes(url=sg_url, db=sg_db, since=changes_3["last_seq"], auth=seth_auth)
assert len(changes_4["results"]) == 1
assert changes_4["results"][0]["id"] == "test_doc"
assert changes_4["results"][0]["changes"][0]["rev"] == "3-foo"
# Issue a oneshot changes since changes_4 last_seq and assert no results are returned
changes_5 = client.get_changes(url=sg_url, db=sg_db, since=changes_4["last_seq"], feed="normal", auth=seth_auth)
assert len(changes_5["results"]) == 0
def test_longpoll_awaken_via_sync_role(params_from_base_test_setup, sg_conf_name):
"""
Test that longpoll changes feed wakes up on role() in sync_function
The contrived sync_function below is used:
function(doc, oldDoc){
if(doc._id == "role_doc_0") {
console.log("granting_access!");
role(["adam", "traun", "andy"], "role:techno");
}
channel(doc, doc.channels);
}
"""
cluster_conf = params_from_base_test_setup["cluster_config"]
cluster_topology = params_from_base_test_setup["cluster_topology"]
mode = params_from_base_test_setup["mode"]
sg_conf = sync_gateway_config_path_for_mode(sg_conf_name, mode)
sg_admin_url = cluster_topology["sync_gateways"][0]["admin"]
sg_url = cluster_topology["sync_gateways"][0]["public"]
log_info("sg_conf: {}".format(sg_conf))
log_info("sg_admin_url: {}".format(sg_admin_url))
log_info("sg_url: {}".format(sg_url))
sg_db = "db"
techno_role = "techno"
techno_channel = "aphex"
cluster = Cluster(config=cluster_conf)
cluster.reset(sg_config_path=sg_conf)
client = MobileRestClient()
client.create_role(url=sg_admin_url, db=sg_db, name=techno_role, channels=[techno_channel])
admin_user_info = userinfo.UserInfo(name="admin", password="******", channels=[], roles=[techno_role])
adam_user_info = userinfo.UserInfo(name="adam", password="******", channels=[], roles=[])
traun_user_info = userinfo.UserInfo(name="traun", password="******", channels=[], roles=[])
andy_user_info = userinfo.UserInfo(name="andy", password="******", channels=[], roles=[])
admin_auth = client.create_user(url=sg_admin_url, db=sg_db,
name=admin_user_info.name, password=admin_user_info.password, roles=adam_user_info.roles)
adam_auth = client.create_user(url=sg_admin_url, db=sg_db,
name=adam_user_info.name, password=adam_user_info.password)
traun_auth = client.create_user(url=sg_admin_url, db=sg_db,
name=traun_user_info.name, password=traun_user_info.password)
andy_auth = client.create_user(url=sg_admin_url, db=sg_db,
name=andy_user_info.name, password=andy_user_info.password)
client.add_docs(url=sg_url, db=sg_db, number=1, id_prefix="techno_doc", channels=[techno_channel], auth=admin_auth)
# Get starting sequence of docs, use the last seq to progress past any _user docs.
adam_changes = client.get_changes(url=sg_url, db=sg_db, since=0, feed="normal", auth=adam_auth)
traun_changes = client.get_changes(url=sg_url, db=sg_db, since=0, feed="normal", auth=traun_auth)
andy_changes = client.get_changes(url=sg_url, db=sg_db, since=0, feed="normal", auth=andy_auth)
with concurrent.futures.ProcessPoolExecutor() as ex:
# Start changes feed for 3 users from latest last_seq
adam_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=adam_changes["last_seq"], timeout=10, auth=adam_auth)
traun_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=traun_changes["last_seq"], timeout=10, auth=traun_auth)
andy_changes_task = ex.submit(client.get_changes, url=sg_url, db=sg_db, since=andy_changes["last_seq"], timeout=10, auth=andy_auth)
# Wait for changes feed to notice there are no changes and enter wait. 2 seconds should be more than enough
time.sleep(2)
# Make sure the changes future is still running and has not exited due to any new changes, the feed should be caught up
# and waiting
assert not adam_changes_task.done()
assert not traun_changes_task.done()
assert not andy_changes_task.done()
# Grant adam, traun and andy access to the "NATGEO" channel
client.add_docs(url=sg_url, db=sg_db, number=1, id_prefix="role_doc", channels=[], auth=admin_auth)
# Changes feed should wake up with the natgeo_0 doc
adam_changes = adam_changes_task.result()
assert len(adam_changes["results"]) == 1
assert adam_changes["results"][0]["id"] == "techno_doc_0"
assert adam_changes["results"][0]["changes"][0]["rev"].startswith("1-")
traun_changes = traun_changes_task.result()
assert len(traun_changes["results"]) == 1
assert traun_changes["results"][0]["id"] == "techno_doc_0"
assert traun_changes["results"][0]["changes"][0]["rev"].startswith("1-")
andy_changes = andy_changes_task.result()
assert len(andy_changes["results"]) == 1
assert andy_changes["results"][0]["id"] == "techno_doc_0"
assert andy_changes["results"][0]["changes"][0]["rev"].startswith("1-")
# Assert that the changes are caught up and should recieve no new changes from last_seq
# Test for https://github.com/couchbase/sync_gateway/issues/2186
adam_changes = client.get_changes(url=sg_url, db=sg_db, since=adam_changes["last_seq"], auth=adam_auth, timeout=1)
assert len(adam_changes["results"]) == 0
traun_changes = client.get_changes(url=sg_url, db=sg_db, since=traun_changes["last_seq"], auth=traun_auth, timeout=1)
assert len(traun_changes["results"]) == 0
andy_changes = client.get_changes(url=sg_url, db=sg_db, since=andy_changes["last_seq"], auth=andy_auth, timeout=1)
assert len(andy_changes["results"]) == 0
def test_backfill_channels_oneshot_limit_changes(params_from_base_test_setup,
sg_conf_name, grant_type):
"""
Test that checks that docs are backfilled for one shot changes with limit for a access grant (via REST or SYNC)
CHANNEL-REST = Channel is granted to user via REST
CHANNEL-SYNC = Channel is granted to user via sync function access()
ROLE-REST = Role is granted to user via REST
ROLE-SYNC = Role is granted to user via sync function role()
CHANNEL-TO-ROLE-REST = Channel is added to existing role via REST
CHANNEL-TO-ROLE-SYNC = Channel is added to existing role via sync access()
"""
cluster_config = params_from_base_test_setup["cluster_config"]
topology = params_from_base_test_setup["cluster_topology"]
mode = params_from_base_test_setup["mode"]
sg_url = topology["sync_gateways"][0]["public"]
sg_admin_url = topology["sync_gateways"][0]["admin"]
sg_db = "db"
log_info("grant_type: {}".format(grant_type))
sg_conf = sync_gateway_config_path_for_mode(sg_conf_name, mode)
cluster = Cluster(cluster_config)
cluster.reset(sg_conf)
client = MobileRestClient()
admin_user_info = userinfo.UserInfo("admin",
"pass",
channels=["A"],
roles=[])
if grant_type == "CHANNEL-TO-ROLE-REST" or grant_type == "CHANNEL-TO-ROLE-SYNC":
client.create_role(url=sg_admin_url,
db=sg_db,
name="empty_role",
channels=[])
user_b_user_info = userinfo.UserInfo("USER_B",
"pass",
channels=["B"],
roles=["empty_role"])
else:
user_b_user_info = userinfo.UserInfo("USER_B",
"pass",
channels=["B"],
roles=[])
# Create users / sessions
client.create_user(url=sg_admin_url,
db=sg_db,
name=admin_user_info.name,
password=admin_user_info.password,
channels=admin_user_info.channels)
client.create_user(url=sg_admin_url,
db=sg_db,
name=user_b_user_info.name,
password=user_b_user_info.password,
channels=user_b_user_info.channels,
roles=user_b_user_info.roles)
admin_session = client.create_session(url=sg_admin_url,
db=sg_db,
name=admin_user_info.name,
password=admin_user_info.password)
user_b_session = client.create_session(url=sg_admin_url,
db=sg_db,
name=user_b_user_info.name,
password=user_b_user_info.password)
# Create 50 "A" channel docs
a_docs = client.add_docs(url=sg_url,
db=sg_db,
number=50,
id_prefix=None,
auth=admin_session,
channels=["A"])
assert len(a_docs) == 50
b_docs = client.add_docs(url=sg_url,
db=sg_db,
number=1,
id_prefix="b_doc",
auth=user_b_session,
channels=["B"])
assert len(b_docs) == 1
# Loop until admin user sees docs in changes
client.verify_docs_in_changes(url=sg_url,
db=sg_db,
expected_docs=a_docs,
auth=admin_session)
user_doc = {"id": "_user/USER_B", "rev": None}
b_docs.append(user_doc)
# Loop until user_b sees b_doc_0 doc and _user/USER_B doc
client.verify_docs_in_changes(url=sg_url,
db=sg_db,
expected_docs=b_docs,
auth=user_b_session,
strict=True)
# Get last_seq for user_b
user_b_changes = client.get_changes(url=sg_url,
db=sg_db,
since=0,
auth=user_b_session,
feed="normal")
# Grant access to channel "A"
if grant_type == "CHANNEL-REST":
log_info(
"Granting user access to channel A via Admin REST user update")
# Grant via update to user in Admin API
client.update_user(url=sg_admin_url,
db=sg_db,
name=user_b_user_info.name,
channels=["A", "B"])
elif grant_type == "CHANNEL-SYNC":
log_info("Granting user access to channel A sync function access()")
# Grant via access() in sync_function, then id 'channel_access' will trigger an access(doc.users, doc.channels)
access_doc = document.create_doc("channel_access", channels=["A"])
access_doc["users"] = ["USER_B"]
client.add_doc(url=sg_url,
db=sg_db,
doc=access_doc,
auth=admin_session)
elif grant_type == "ROLE-REST":
log_info("Granting user access to channel A via Admin REST role grant")
# Create role with channel A
client.create_role(url=sg_admin_url,
db=sg_db,
name="channel-A-role",
channels=["A"])
client.update_user(url=sg_admin_url,
db=sg_db,
name="USER_B",
roles=["channel-A-role"])
elif grant_type == "ROLE-SYNC":
log_info(
"Granting user access to channel A via sync function role() grant")
# Create role with channel A
client.create_role(url=sg_admin_url,
db=sg_db,
name="channel-A-role",
channels=["A"])
# Grant via role() in sync_function, then id 'role_access' will trigger an role(doc.users, doc.roles)
role_access_doc = document.create_doc("role_access")
role_access_doc["users"] = ["USER_B"]
role_access_doc["roles"] = ["role:channel-A-role"]
client.add_doc(sg_url,
db=sg_db,
doc=role_access_doc,
auth=admin_session)
elif grant_type == "CHANNEL-TO-ROLE-REST":
# Update the empty_role to have channel "A"
client.update_role(url=sg_admin_url,
db=sg_db,
name="empty_role",
channels=["A"])
elif grant_type == "CHANNEL-TO-ROLE-SYNC":
# Grant empty_role access to channel "A" via sync function
# Grant channel access to role via sync function
access_doc = document.create_doc("channel_grant_to_role")
access_doc["roles"] = ["role:empty_role"]
access_doc["channels"] = ["A"]
client.add_doc(url=sg_url,
db=sg_db,
doc=access_doc,
auth=admin_session,
use_post=True)
else:
pytest.fail("Unsupported grant_type!!!!")
# Create a dictionary keyed on doc id for all of channel A docs
ids_and_revs_from_a_docs = {doc["id"]: doc["rev"] for doc in a_docs}
assert len(ids_and_revs_from_a_docs.keys()) == 50
log_info("Doing 3, 1 shot changes with limit and last seq!")
# Issue 3 oneshot changes with a limit of 20
# Issue one shot changes to make sure access grant is successful, the change may not propagate immediately so retry.
num_retries = 3
count = 0
while True:
if count == num_retries:
raise exceptions.ChangesError(
"Didn't get all expected changes before timing out!")
user_b_changes_after_grant_one = client.get_changes(
url=sg_url,
db=sg_db,
since=user_b_changes["last_seq"],
auth=user_b_session,
feed="normal",
limit=20)
if len(user_b_changes_after_grant_one["results"]) > 0:
# Found changes, break out an validate changes!
break
time.sleep(1)
count += 1
#################
# Changes Req #1
#################
# Expect a user doc in the changes
if grant_type == "CHANNEL-REST" or grant_type == "ROLE-REST":
ids_and_revs_from_a_docs["_user/USER_B"] = None
# User B shoud have recieved 20 docs due to limit
assert len(user_b_changes_after_grant_one["results"]) == 20
for doc in user_b_changes_after_grant_one["results"]:
# cross off keys found from 'a_docs' dictionary
del ids_and_revs_from_a_docs[doc["id"]]
#################
# Changes Req #2
#################
user_b_changes_after_grant_two = client.get_changes(
url=sg_url,
db=sg_db,
since=user_b_changes_after_grant_one["last_seq"],
auth=user_b_session,
feed="normal",
limit=20)
# User B shoud have recieved 20 docs due to limit
assert len(user_b_changes_after_grant_two["results"]) == 20
for doc in user_b_changes_after_grant_two["results"]:
# cross off keys found from 'a_docs' dictionary
del ids_and_revs_from_a_docs[doc["id"]]
#################
# Changes Req #3
#################
user_b_changes_after_grant_three = client.get_changes(
url=sg_url,
db=sg_db,
since=user_b_changes_after_grant_two["last_seq"],
auth=user_b_session,
feed="normal",
limit=20)
# User B should have recieved 10 docs due to limit or 11 docs with with a terminating _user doc
# The terminating user doc only happens with a grant via REST
if grant_type == "CHANNEL-REST" or grant_type == "ROLE-REST":
assert len(user_b_changes_after_grant_three["results"]) == 11
else:
assert len(user_b_changes_after_grant_three["results"]) == 10
for doc in user_b_changes_after_grant_three["results"]:
# cross off non user doc keys found from 'a_docs' dictionary
del ids_and_revs_from_a_docs[doc["id"]]
# Make sure all the docs have been crossed out
assert len(ids_and_revs_from_a_docs) == 0
#################
# Changes Req #4
#################
user_b_changes_after_grant_four = client.get_changes(
url=sg_url,
db=sg_db,
since=user_b_changes_after_grant_three["last_seq"],
auth=user_b_session,
feed="normal",
limit=20)
# Changes should be caught up and there should be no results
assert len(user_b_changes_after_grant_four["results"]) == 0
def test_backfill_channels_oneshot_limit_changes(params_from_base_test_setup, sg_conf_name, grant_type):
cluster_config = params_from_base_test_setup["cluster_config"]
topology = params_from_base_test_setup["cluster_topology"]
mode = params_from_base_test_setup["mode"]
sg_url = topology["sync_gateways"][0]["public"]
sg_admin_url = topology["sync_gateways"][0]["admin"]
sg_db = "db"
log_info("grant_type: {}".format(grant_type))
sg_conf = sync_gateway_config_path_for_mode(sg_conf_name, mode)
cluster = Cluster(cluster_config)
cluster.reset(sg_conf)
client = MobileRestClient()
admin_user_info = userinfo.UserInfo("admin", "pass", channels=["A"], roles=[])
user_b_user_info = userinfo.UserInfo("USER_B", "pass", channels=["B"], roles=[])
# Create users / sessions
client.create_user(url=sg_admin_url, db=sg_db,
name=admin_user_info.name, password=admin_user_info.password, channels=admin_user_info.channels)
client.create_user(url=sg_admin_url, db=sg_db,
name=user_b_user_info.name, password=user_b_user_info.password, channels=user_b_user_info.channels)
admin_session = client.create_session(url=sg_admin_url, db=sg_db, name=admin_user_info.name, password=admin_user_info.password)
user_b_session = client.create_session(url=sg_admin_url, db=sg_db, name=user_b_user_info.name, password=user_b_user_info.password)
# Create 50 "A" channel docs
a_docs = client.add_docs(url=sg_url, db=sg_db, number=50, id_prefix=None, auth=admin_session, channels=["A"])
assert len(a_docs) == 50
b_docs = client.add_docs(url=sg_url, db=sg_db, number=1, id_prefix="b_doc", auth=user_b_session, channels=["B"])
assert len(b_docs) == 1
user_doc = {"id": "_user/USER_B", "rev": None}
b_docs.append(user_doc)
# Loop until user_b sees b_doc_0 doc and _user/USER_B doc
client.verify_docs_in_changes(url=sg_url, db=sg_db, expected_docs=b_docs, auth=user_b_session, strict=True)
# Get last_seq for user_b
user_b_changes = client.get_changes(url=sg_url, db=sg_db, since=0, auth=user_b_session, feed="normal")
# Grant access to channel "A"
if grant_type == "CHANNEL-REST":
log_info("Granting user access to channel A via Admin REST user update")
# Grant via update to user in Admin API
client.update_user(url=sg_admin_url, db=sg_db,
name=user_b_user_info.name, channels=["A", "B"])
elif grant_type == "CHANNEL-SYNC":
log_info("Granting user access to channel A sync function access()")
# Grant via access() in sync_function, then id 'channel_access' will trigger an access(doc.users, doc.channels)
access_doc = document.create_doc("channel_access", channels=["A"])
access_doc["users"] = ["USER_B"]
client.add_doc(url=sg_url, db=sg_db, doc=access_doc, auth=admin_session)
elif grant_type == "ROLE-REST":
log_info("Granting user access to channel A via Admin REST role grant")
# Create role with channel A
client.create_role(url=sg_admin_url, db=sg_db, name="channel-A-role", channels=["A"])
client.update_user(url=sg_admin_url, db=sg_db, name="USER_B", roles=["channel-A-role"])
elif grant_type == "ROLE-SYNC":
log_info("Granting user access to channel A via sync function role() grant")
# Create role with channel A
client.create_role(url=sg_admin_url, db=sg_db, name="channel-A-role", channels=["A"])
# Grant via role() in sync_function, then id 'role_access' will trigger an role(doc.users, doc.roles)
role_access_doc = document.create_doc("role_access")
role_access_doc["users"] = ["USER_B"]
role_access_doc["roles"] = ["role:channel-A-role"]
client.add_doc(sg_url, db=sg_db, doc=role_access_doc, auth=admin_session)
else:
pytest.fail("Unsupported grant_type!!!!")
# Create a dictionary keyed on doc id for all of channel A docs
ids_and_revs_from_a_docs = {doc["id"]: doc["rev"] for doc in a_docs}
assert len(ids_and_revs_from_a_docs.keys()) == 50
log_info("Doing 3, 1 shot changes with limit and last seq!")
# Issue 3 oneshot changes with a limit of 20
#################
# Changes Req #1
#################
user_b_changes_after_grant_one = client.get_changes(url=sg_url, db=sg_db,
since=user_b_changes["last_seq"], auth=user_b_session, feed="normal", limit=20)
# User B shoud have recieved 20 docs due to limit
assert len(user_b_changes_after_grant_one["results"]) == 20
for doc in user_b_changes_after_grant_one["results"]:
# cross off keys found from 'a_docs' dictionary
del ids_and_revs_from_a_docs[doc["id"]]
#################
# Changes Req #2
#################
user_b_changes_after_grant_two = client.get_changes(url=sg_url, db=sg_db,
since=user_b_changes_after_grant_one["last_seq"],
auth=user_b_session, feed="normal", limit=20)
# User B shoud have recieved 20 docs due to limit
assert len(user_b_changes_after_grant_two["results"]) == 20
for doc in user_b_changes_after_grant_two["results"]:
# cross off keys found from 'a_docs' dictionary
del ids_and_revs_from_a_docs[doc["id"]]
#################
# Changes Req #3
#################
user_b_changes_after_grant_three = client.get_changes(url=sg_url, db=sg_db,
since=user_b_changes_after_grant_two["last_seq"],
auth=user_b_session, feed="normal", limit=20)
# User B shoud have recieved 20 docs due to limit
assert len(user_b_changes_after_grant_three["results"]) == 10
for doc in user_b_changes_after_grant_three["results"]:
# cross off keys found from 'a_docs' dictionary
del ids_and_revs_from_a_docs[doc["id"]]
# Make sure all the docs have been crossed out
assert len(ids_and_revs_from_a_docs) == 0
#################
# Changes Req #4
#################
user_b_changes_after_grant_four = client.get_changes(url=sg_url, db=sg_db,
since=user_b_changes_after_grant_three["last_seq"],
auth=user_b_session, feed="normal", limit=20)
# Changes should be caught up and there should be no results
assert len(user_b_changes_after_grant_four["results"]) == 0
def test_backfill_channels_oneshot_changes(params_from_base_test_setup,
sg_conf_name, grant_type):
"""
Test that checks that docs are backfilled for one shot changes for a access grant (via REST or SYNC)
CHANNEL-REST = Channel is granted to user via REST
CHANNEL-SYNC = Channel is granted to user via sync function access()
ROLE-REST = Role is granted to user via REST
ROLE-SYNC = Role is granted to user via sync function role()
CHANNEL-TO-ROLE-REST = Channel is added to existing role via REST
CHANNEL-TO-ROLE-SYNC = Channel is added to existing role via sync access()
"""
cluster_config = params_from_base_test_setup["cluster_config"]
topology = params_from_base_test_setup["cluster_topology"]
mode = params_from_base_test_setup["mode"]
sg_url = topology["sync_gateways"][0]["public"]
sg_admin_url = topology["sync_gateways"][0]["admin"]
sg_db = "db"
log_info("grant_type: {}".format(grant_type))
sg_conf = sync_gateway_config_path_for_mode(sg_conf_name, mode)
cluster = Cluster(cluster_config)
cluster.reset(sg_conf)
client = MobileRestClient()
admin_user_info = userinfo.UserInfo("admin",
"pass",
channels=["A"],
roles=[])
if grant_type == "CHANNEL-TO-ROLE-REST" or grant_type == "CHANNEL-TO-ROLE-SYNC":
client.create_role(url=sg_admin_url,
db=sg_db,
name="empty_role",
channels=[])
user_b_user_info = userinfo.UserInfo("USER_B",
"pass",
channels=["B"],
roles=["empty_role"])
else:
user_b_user_info = userinfo.UserInfo("USER_B",
"pass",
channels=["B"],
roles=[])
# Create users / sessions
client.create_user(url=sg_admin_url,
db=sg_db,
name=admin_user_info.name,
password=admin_user_info.password,
channels=admin_user_info.channels)
client.create_user(url=sg_admin_url,
db=sg_db,
name=user_b_user_info.name,
password=user_b_user_info.password,
channels=user_b_user_info.channels,
roles=user_b_user_info.roles)
admin_session = client.create_session(url=sg_admin_url,
db=sg_db,
name=admin_user_info.name,
password=admin_user_info.password)
user_b_session = client.create_session(url=sg_admin_url,
db=sg_db,
name=user_b_user_info.name,
password=user_b_user_info.password)
# Create 50 "A" channel docs
a_docs = client.add_docs(url=sg_url,
db=sg_db,
number=50,
id_prefix=None,
auth=admin_session,
channels=["A"])
assert len(a_docs) == 50
b_docs = client.add_docs(url=sg_url,
db=sg_db,
number=1,
id_prefix="b_doc",
auth=user_b_session,
channels=["B"])
assert len(b_docs) == 1
user_doc = {"id": "_user/USER_B", "rev": None}
b_docs.append(user_doc)
# Loop until admin user sees docs in changes
client.verify_docs_in_changes(url=sg_url,
db=sg_db,
expected_docs=a_docs,
auth=admin_session)
# Loop until user_b sees b_doc_0 doc and _user/USER_B doc
client.verify_docs_in_changes(url=sg_url,
db=sg_db,
expected_docs=b_docs,
auth=user_b_session,
strict=True)
# Get last_seq for user_b
user_b_changes = client.get_changes(url=sg_url,
db=sg_db,
since=0,
auth=user_b_session,
feed="normal")
# Grant access to channel "A"
if grant_type == "CHANNEL-REST":
log_info(
"Granting user access to channel A via Admin REST user update")
# Grant via update to user in Admin API
client.update_user(url=sg_admin_url,
db=sg_db,
name=user_b_user_info.name,
channels=["A", "B"])
elif grant_type == "CHANNEL-SYNC":
log_info("Granting user access to channel A sync function access()")
# Grant via access() in sync_function, then id 'channel_access' will trigger an access(doc.users, doc.channels)
access_doc = document.create_doc("channel_access", channels=["A"])
access_doc["users"] = ["USER_B"]
client.add_doc(url=sg_url,
db=sg_db,
doc=access_doc,
auth=admin_session)
elif grant_type == "ROLE-REST":
log_info("Granting user access to channel A via Admin REST role grant")
# Create role with channel A
client.create_role(url=sg_admin_url,
db=sg_db,
name="channel-A-role",
channels=["A"])
client.update_user(url=sg_admin_url,
db=sg_db,
name="USER_B",
channels=["B"],
roles=["channel-A-role"])
elif grant_type == "ROLE-SYNC":
log_info(
"Granting user access to channel A via sync function role() grant")
# Create role with channel A
client.create_role(url=sg_admin_url,
db=sg_db,
name="channel-A-role",
channels=["A"])
# Grant via role() in sync_function, then id 'role_access' will trigger an role(doc.users, doc.roles)
role_access_doc = document.create_doc("role_access")
role_access_doc["users"] = ["USER_B"]
role_access_doc["roles"] = ["role:channel-A-role"]
client.add_doc(sg_url,
db=sg_db,
doc=role_access_doc,
auth=admin_session)
elif grant_type == "CHANNEL-TO-ROLE-REST":
# Update the empty_role to have channel "A"
client.update_role(url=sg_admin_url,
db=sg_db,
name="empty_role",
channels=["A"])
elif grant_type == "CHANNEL-TO-ROLE-SYNC":
# Grant empty_role access to channel "A" via sync function
# Grant channel access to role via sync function
access_doc = document.create_doc("channel_grant_to_role")
access_doc["roles"] = ["role:empty_role"]
access_doc["channels"] = ["A"]
client.add_doc(url=sg_url,
db=sg_db,
doc=access_doc,
auth=admin_session,
use_post=True)
else:
pytest.fail("Unsupported grant_type!!!!")
# Issue one shot changes to make sure access grant is successful, the change may not propagate immediately so retry.
num_retries = 3
count = 0
while True:
if count == num_retries:
raise exceptions.ChangesError(
"Didn't get all expected changes before timing out!")
user_b_changes_after_grant = client.get_changes(
url=sg_url,
db=sg_db,
since=user_b_changes["last_seq"],
auth=user_b_session,
feed="normal")
if len(user_b_changes_after_grant["results"]) > 0:
# Found changes, break out an validate changes!
break
time.sleep(1)
count += 1
# User B shoud have recieved 51 docs (a_docs + 1 _user/USER_B doc) if a REST grant or 50 changes if the grant
# is via the sync function
changes_results = user_b_changes_after_grant["results"]
assert 50 <= len(changes_results) <= 51
# Create a dictionary of id rev pair of all the docs that are not "_user/" docs from changes
ids_and_revs_from_user_changes = {
change["id"]: change["changes"][0]["rev"]
for change in changes_results if not change["id"].startswith("_user/")
}
assert len(ids_and_revs_from_user_changes) == 50
# Create a list of id rev pair of all of the channel A docs
ids_and_revs_from_a_docs = {doc["id"]: doc["rev"] for doc in a_docs}
assert len(ids_and_revs_from_a_docs) == 50
# Check that the changes and the a_docs are identical in id and rev
assert ids_and_revs_from_user_changes == ids_and_revs_from_a_docs
# Get changes from last_seq of the changes request after the grant. There should be no new changes
user_b_changes = client.get_changes(
url=sg_url,
db=sg_db,
since=user_b_changes_after_grant["last_seq"],
auth=user_b_session,
feed="normal")
assert len(user_b_changes["results"]) == 0
def test_backfill_channels_looping_longpoll_changes(params_from_base_test_setup, sg_conf_name, grant_type):
cluster_config = params_from_base_test_setup["cluster_config"]
topology = params_from_base_test_setup["cluster_topology"]
mode = params_from_base_test_setup["mode"]
sg_url = topology["sync_gateways"][0]["public"]
sg_admin_url = topology["sync_gateways"][0]["admin"]
sg_db = "db"
log_info("grant_type: {}".format(grant_type))
sg_conf = sync_gateway_config_path_for_mode(sg_conf_name, mode)
cluster = Cluster(cluster_config)
cluster.reset(sg_conf)
client = MobileRestClient()
admin_user_info = userinfo.UserInfo("admin", "pass", channels=["A"], roles=[])
user_b_user_info = userinfo.UserInfo("USER_B", "pass", channels=["B"], roles=[])
# Create users / sessions
client.create_user(url=sg_admin_url, db=sg_db,
name=admin_user_info.name, password=admin_user_info.password, channels=admin_user_info.channels)
client.create_user(url=sg_admin_url, db=sg_db,
name=user_b_user_info.name, password=user_b_user_info.password, channels=user_b_user_info.channels)
admin_session = client.create_session(url=sg_admin_url, db=sg_db, name=admin_user_info.name, password=admin_user_info.password)
user_b_session = client.create_session(url=sg_admin_url, db=sg_db, name=user_b_user_info.name, password=user_b_user_info.password)
# Create 50 "A" channel docs
a_docs = client.add_docs(url=sg_url, db=sg_db, number=50, id_prefix=None, auth=admin_session, channels=["A"])
assert len(a_docs) == 50
b_docs = client.add_docs(url=sg_url, db=sg_db, number=1, id_prefix="b_doc", auth=user_b_session, channels=["B"])
assert len(b_docs) == 1
user_doc = {"id": "_user/USER_B", "rev": None}
b_docs.append(user_doc)
# Loop until user_b sees b_doc_0 doc and _user/USER_B doc
client.verify_docs_in_changes(url=sg_url, db=sg_db, expected_docs=b_docs, auth=user_b_session, strict=True)
# Create a dictionary keyed on doc id for all of channel A docs
ids_and_revs_from_a_docs = {doc["id"]: doc["rev"] for doc in a_docs}
assert len(ids_and_revs_from_a_docs.keys()) == 50
# Get last_seq for user_b
user_b_changes = client.get_changes(url=sg_url, db=sg_db, since=0, auth=user_b_session, feed="normal")
with concurrent.futures.ProcessPoolExecutor() as ex:
# Start long poll changes feed.
changes_task = ex.submit(client.get_changes,
url=sg_url, db=sg_db, since=user_b_changes["last_seq"], auth=user_b_session, timeout=10, limit=20)
# Grant access to channel "A"
if grant_type == "CHANNEL-REST":
log_info("Granting user access to channel A via Admin REST user update")
# Grant via update to user in Admin API
client.update_user(url=sg_admin_url, db=sg_db,
name=user_b_user_info.name, channels=["A", "B"])
elif grant_type == "CHANNEL-SYNC":
log_info("Granting user access to channel A sync function access()")
# Grant via access() in sync_function, then id 'channel_access' will trigger an access(doc.users, doc.channels)
access_doc = document.create_doc("channel_access", channels=["A"])
access_doc["users"] = ["USER_B"]
client.add_doc(url=sg_url, db=sg_db, doc=access_doc, auth=admin_session)
elif grant_type == "ROLE-REST":
log_info("Granting user access to channel A via Admin REST role grant")
# Create role with channel A
client.create_role(url=sg_admin_url, db=sg_db, name="channel-A-role", channels=["A"])
client.update_user(url=sg_admin_url, db=sg_db, name="USER_B", roles=["channel-A-role"])
elif grant_type == "ROLE-SYNC":
log_info("Granting user access to channel A via sync function role() grant")
# Create role with channel A
client.create_role(url=sg_admin_url, db=sg_db, name="channel-A-role", channels=["A"])
# Grant via role() in sync_function, then id 'role_access' will trigger an role(doc.users, doc.roles)
role_access_doc = document.create_doc("role_access")
role_access_doc["users"] = ["USER_B"]
role_access_doc["roles"] = ["role:channel-A-role"]
client.add_doc(sg_url, db=sg_db, doc=role_access_doc, auth=admin_session)
else:
pytest.fail("Unsupported grant_type!!!!")
# Block on return of longpoll changes, feed should wake up and return 20 results
changes = changes_task.result()
assert len(changes["results"]) == 20
num_requests = 1
# Cross the results off from the 'a_docs' dictionary
for doc in changes["results"]:
del ids_and_revs_from_a_docs[doc["id"]]
# Start looping longpoll changes with limit, cross off changes from dictionary each time one is found
# Since 20 changes should be crossed off already, this should execute 2x.
log_info("Starting looping longpoll changes with limit!")
last_seq = changes["last_seq"]
while True:
if len(ids_and_revs_from_a_docs.keys()) == 0:
log_info("All docs were found! Exiting polling loop")
break
changes = client.get_changes(url=sg_url, db=sg_db, since=last_seq, auth=user_b_session, limit=20, timeout=10)
num_requests += 1
# There are more than 2 requests, throw an exception.
if num_requests == 2:
assert len(changes["results"]) == 20
elif num_requests == 3:
# This will be 10 or 11 depending on if the _user/ doc is returned
assert 10 <= len(changes["results"]) <= 11
else:
raise exceptions.ChangesError("Looping longpoll should only have to perform 3 requests to get all the changes!!")
# Cross the results off from the 'a_docs' dictionary.
# This will blow up in docs duplicate docs are sent to changes
for doc in changes["results"]:
if doc["id"] != "_user/USER_B":
del ids_and_revs_from_a_docs[doc["id"]]
last_seq = changes["last_seq"]
# Shanges after longpoll
zero_results = client.get_changes(url=sg_url, db=sg_db,
since=last_seq,
auth=user_b_session, feed="normal")
# Changes should be caught up and there should be no results
assert len(zero_results["results"]) == 0
def test_rollback_server_reset(params_from_base_test_setup, sg_conf_name):
"""
Test for sync gateway resiliency under Couchbase Server rollback
Scenario
1. Create user (seth:pass) and session
2. Add docs targeting all vbuckets except 66
3. Add docs to vbucket 66
4. Verify the docs show up in seth's changes feed
5. Delete vBucket 66 file on server
6. Restart server
7. User should only see docs not in vbucket 66
"""
num_vbuckets = 1024
cluster_config = params_from_base_test_setup["cluster_config"]
topology = params_from_base_test_setup["cluster_topology"]
mode = params_from_base_test_setup["mode"]
sg_url = topology["sync_gateways"][0]["public"]
sg_admin_url = topology["sync_gateways"][0]["admin"]
cb_server_url = topology["couchbase_servers"][0]
cb_server = couchbaseserver.CouchbaseServer(cb_server_url)
sg_db = "db"
if mode == "cc":
pytest.skip("Rollback not supported in channel cache mode")
sg_conf = sync_gateway_config_path_for_mode(sg_conf_name, mode)
cluster = Cluster(cluster_config)
cluster.reset(sg_conf)
client = MobileRestClient()
seth_user_info = userinfo.UserInfo("seth",
"pass",
channels=["NASA"],
roles=[])
client.create_user(url=sg_admin_url,
db=sg_db,
name=seth_user_info.name,
password=seth_user_info.password,
channels=seth_user_info.channels)
seth_session = client.create_session(url=sg_admin_url,
db=sg_db,
name=seth_user_info.name,
password=seth_user_info.password)
# create a doc that will hash to each vbucket in parallel except for vbucket 66
doc_id_for_every_vbucket_except_66 = []
with concurrent.futures.ProcessPoolExecutor() as pex:
futures = [
pex.submit(document.generate_doc_id_for_vbucket, i)
for i in range(num_vbuckets) if i != 66
]
for future in concurrent.futures.as_completed(futures):
doc_id = future.result()
doc = document.create_doc(doc_id=doc_id,
channels=seth_user_info.channels)
doc_id_for_every_vbucket_except_66.append(doc)
vbucket_66_docs = []
for _ in range(5):
vbucket_66_docs.append(
document.create_doc(
doc_id=document.generate_doc_id_for_vbucket(66),
channels=seth_user_info.channels))
seth_docs = client.add_bulk_docs(url=sg_url,
db=sg_db,
docs=doc_id_for_every_vbucket_except_66,
auth=seth_session)
seth_66_docs = client.add_bulk_docs(url=sg_url,
db=sg_db,
docs=vbucket_66_docs,
auth=seth_session)
assert len(seth_docs) == num_vbuckets - 1
assert len(seth_66_docs) == 5
# Verify the all docs show up in seth's changes feed
all_docs = seth_docs + seth_66_docs
assert len(all_docs) == (num_vbuckets - 1) + 5
client.verify_docs_in_changes(url=sg_url,
db=sg_db,
expected_docs=all_docs,
auth=seth_session)
# Delete vbucket and restart server
cb_server.delete_vbucket(66, "data-bucket")
cb_server.restart()
max_retries = 50
count = 0
while count != max_retries:
# Try to get changes, sync gateway should be able to recover and return changes
# A changes since=0 should now be in a rolled back state due to the data loss from the removed vbucket
# Seth should only see the docs not present in vbucket 66, unlike all the docs as above.
try:
changes = client.get_changes(url=sg_url,
db=sg_db,
since=0,
auth=seth_session)
changes_ids = [
change["id"] for change in changes["results"]
if not change["id"].startswith("_user")
]
log_info("length of Changes ids are {} and vbuckets {}".format(
len(changes_ids), num_vbuckets))
if len(changes_ids) == (num_vbuckets - 1):
break
except HTTPError:
if changes.status_code == 503:
log_info('server is still down')
else:
raise
time.sleep(1)
count += 1
# Verify that seth 66 doc does not appear in changes as vbucket 66 got deleted
vbucket_66_docids = [doc1["id"] for doc1 in seth_66_docs]
for doc_66 in vbucket_66_docids:
assert doc_66 not in changes_ids, "doc {} in vbucket 66 shows up in changes ".format(
doc_66)
