start_cluster = True, cluster = <cluster.Cluster object at 0x7f92b885c590>

    @pytest.mark.testcase(test_case_key="T204", test_step_key=1)
    @pytest.mark.timeout(300,func_only=True)
    def test_logical(start_cluster,cluster):
        cluster.check_pbm_status()
    
        client = pymongo.MongoClient(cluster.connection)
        db = client.test
        collection = db.test
        Cluster.log("Create collection, unique index and insert data")
        collection.insert_one({"a": 1, "b": 1, "c": 1})
        collection.create_index([("a",1),("b",1),("c",1)], name='test_index', unique = True)
        res = pymongo.MongoClient(cluster.connection)["test"]["test"].find({})
        Cluster.log('Collection:')
        for r in res:
            Cluster.log(r)
    
        def upsert_1():
            Cluster.log("Starting background upsert 1")
            while upsert:
                query = {"a": 1}
                update = {"$set": {"a": 1, "b": 1, "c": 1}}
                pymongo.MongoClient(cluster.connection)['test']['test'].delete_one(query)
                try:
                    doc = pymongo.MongoClient(cluster.connection)['test']['test'].find_one_and_update(query,update,upsert=True,return_document=pymongo.collection.ReturnDocument.AFTER)
                    #Cluster.log(doc)
                except pymongo.errors.DuplicateKeyError:
                    pass
            Cluster.log("Stopping background upsert 1")
    
        def upsert_2():
            Cluster.log("Starting background upsert 2")
            while upsert:
                query = {"b": 1}
                update = {"$set": {"a": 2, "b": 1, "c": 1}}
                pymongo.MongoClient(cluster.connection)['test']['test'].delete_one(query)
                try:
                    doc = pymongo.MongoClient(cluster.connection)['test']['test'].find_one_and_update(query,update,upsert=True,return_document=pymongo.collection.ReturnDocument.AFTER)
                    #Cluster.log(doc)
                except pymongo.errors.DuplicateKeyError:
                    pass
            Cluster.log("Stopping background upsert 2")
    
        upsert=True
        t1 = threading.Thread(target=upsert_1)
        t2 = threading.Thread(target=upsert_2)
        t1.start()
        t2.start()
    
>       backup = cluster.make_backup("logical")

test_PBM-1090.py:89: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <cluster.Cluster object at 0x7f92b885c590>, type = 'logical'

    def make_backup(self, type):
        n = testinfra.get_host("docker://" + self.pbm_cli)
        timeout = time.time() + 120
        while True:
            running = self.get_status()['running']
            Cluster.log("Current operation: " + str(running))
            if not running:
                if type:
                    start = n.check_output(
                        'pbm backup --out=json --type=' + type)
                else:
                    start = n.check_output('pbm backup --out=json')
                name = json.loads(start)['name']
                Cluster.log("Backup started")
                break
            if time.time() > timeout:
                assert False
            time.sleep(1)
        timeout = time.time() + 600
        while True:
            status = self.get_status()
            Cluster.log("Current operation: " + str(status['running']))
            if status['backups']['snapshot']:
                for snapshot in status['backups']['snapshot']:
                    if snapshot['name'] == name:
                        if snapshot['status'] == 'done':
                            Cluster.log("Backup found: " + str(snapshot))
                            return name
                            break
                        elif snapshot['status'] == 'error':
                            self.get_logs()
                            assert False, snapshot['error']
                            break
            if time.time() > timeout:
                assert False, "Backup timeout exceeded"
>           time.sleep(1)
E           Failed: Timeout >300.0s

cluster.py:408: Failed

start_cluster = True, cluster = <cluster.Cluster object at 0x7f92b5359790>

    @pytest.mark.testcase(test_case_key="T249", test_step_key=1)
    @pytest.mark.timeout(300,func_only=True)
    def test_logical(start_cluster,cluster):
        cluster.check_pbm_status()
        client = pymongo.MongoClient(cluster.connection)
        db = client.test
        collection = db.test
        with client.start_session() as session:
            with session.start_transaction():
                Cluster.log("Transaction started\n")
                collection.insert_one({"e": 5}, session=session)
                collection.insert_one({"f": 6}, session=session)
                collection.insert_one({"g": 7}, session=session)
                collection.insert_one({"h": 8}, session=session)
                collection.insert_one({"i": 9}, session=session)
                background_backup=concurrent.futures.ThreadPoolExecutor().submit(cluster.make_backup, 'logical')
                time.sleep(1)
                collection.insert_one({"j": 10}, session=session)
                collection.insert_one({"k": 11}, session=session)
                collection.insert_one({"l": 12}, session=session)
                session.commit_transaction()
                Cluster.log("Transaction commited\n")
        backup=background_backup.result()
        assert pymongo.MongoClient(cluster.connection)["test"]["test"].count_documents({}) == 8
>       cluster.make_restore(backup,check_pbm_status=True)

test_PBM-1223.py:79: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <cluster.Cluster object at 0x7f92b5359790>, name = '2024-01-26T08:11:34Z'
kwargs = {'check_pbm_status': True}
client = MongoClient(host=['mongos:27017'], document_class=dict, tz_aware=False, connect=True)
result = CommandResult(backend=<testinfra.backend.docker.DockerBackend object at 0x7f92b909d190>, exit_status=1, command=b'time... id SAAAAAVpZAAQAAAABGF1CFXWZ0yorIn+GQ8qq0QFdWlkACAAAAAAY5mrDaxi8gv8RmdTsQ+1j7fmkr7JUsabhNmXAheU0fgA-1\n', _stderr=b'')
n = <testinfra.host.Host docker://rscfg01>, timeout = 1706256775.306483

    def make_restore(self, name, **kwargs):
        if self.layout == "sharded":
            client = pymongo.MongoClient(self.connection)
            result = client.admin.command("balancerStop")
            client.close()
            Cluster.log("Stopping balancer: " + str(result))
            self.stop_mongos()
        self.stop_arbiters()
        n = testinfra.get_host("docker://" + self.pbm_cli)
        timeout = time.time() + 60
    
        while True:
            if not self.get_status()['running']:
                break
            if time.time() > timeout:
                assert False, "Cannot start restore, another operation running"
            time.sleep(1)
        Cluster.log("Restore started")
        result = n.run('timeout 240 pbm restore ' + name + ' --wait')
        if result.rc == 124:
            # try to catch possible failures if timeout exceeded
            for host in self.mongod_hosts:
                try:
                    container = docker.from_env().containers.get(host)
                    get_logs = container.exec_run(
                        'cat /var/lib/mongo/pbm.restore.log', stderr=False)
                    if get_logs.exit_code == 0:
                        Cluster.log(
                            "!!!!Possible failure on {}, file pbm.restore.log was found:".format(host))
                        Cluster.log(get_logs.output.decode('utf-8'))
                except docker.errors.APIError:
                    pass
            assert False, "Timeout for restore exceeded"
        elif result.rc == 0:
            Cluster.log(result.stdout)
        else:
>           assert False, result.stdout + result.stderr
E           AssertionError: Starting restore 2024-01-26T08:11:56.617214162Z from '2024-01-26T08:11:34Z'...Started logical restore.
E           Waiting to finish....Error: operation failed with: waiting for dumpDone: cluster failed: reply oplog: replay chunk 1706256695.1706256699: apply oplog for chunk: applying a transaction entry: apply txn: {
E            "Timestamp": {
E             "T": 1706256695,
E             "I": 9
E            },
E            "Term": 1,
E            "Hash": null,
E            "Version": 2,
E            "Operation": "c",
E            "Namespace": "admin.$cmd",
E            "Object": [
E             {
E              "Key": "commitTransaction",
E              "Value": 1
E             },
E             {
E              "Key": "commitTimestamp",
E              "Value": {
E               "T": 1706256695,
E               "I": 7
E              }
E             }
E            ],
E            "Query": null,
E            "UI": null,
E            "LSID": "SAAAAAVpZAAQAAAABGF1CFXWZ0yorIn+GQ8qq0QFdWlkACAAAAAAY5mrDaxi8gv8RmdTsQ+1j7fmkr7JUsabhNmXAheU0fgA",
E            "TxnNumber": 1,
E            "PrevOpTime": "HAAAABF0cwAFAAAAN2mzZRJ0AAEAAAAAAAAAAA=="
E           }: unknown transaction id SAAAAAVpZAAQAAAABGF1CFXWZ0yorIn+GQ8qq0QFdWlkACAAAAAAY5mrDaxi8gv8RmdTsQ+1j7fmkr7JUsabhNmXAheU0fgA-1

cluster.py:450: AssertionError

start_cluster = True, cluster = <cluster.Cluster object at 0x7f92b87f2050>

    @pytest.mark.timeout(500, func_only=True)
    def test_logical_pitr(start_cluster,cluster):
        cluster.check_pbm_status()
        pymongo.MongoClient(cluster.connection)["test"]["test"].insert_many(documents)
        backup_l1=cluster.make_backup("logical")
        cluster.enable_pitr(pitr_extra_args="--set pitr.oplogSpanMin=0.5")
        time.sleep(60)
        # make several following backups and then remove them to check the continuity of PITR timeframe
        pymongo.MongoClient(cluster.connection)["test"]["test2"].insert_many(documents)
        backup_l2=cluster.make_backup("logical")
        time.sleep(60)
        pymongo.MongoClient(cluster.connection)["test"]["test3"].insert_many(documents)
        backup_l3=cluster.make_backup("logical")
        pitr = datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%S")
        backup="--time=" + pitr
        Cluster.log("Time for PITR is: " + pitr)
        time.sleep(60)
        cluster.delete_backup(backup_l2)
        cluster.delete_backup(backup_l3)
        cluster.disable_pitr()
        time.sleep(10)
        pymongo.MongoClient(cluster.connection).drop_database('test')
>       cluster.make_restore(backup,check_pbm_status=True)

test_azurite.py:97: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <cluster.Cluster object at 0x7f92b87f2050>
name = '--time=2024-01-26T08:22:05', kwargs = {'check_pbm_status': True}
client = MongoClient(host=['mongos:27017'], document_class=dict, tz_aware=False, connect=True)
result = CommandResult(backend=<testinfra.backend.docker.DockerBackend object at 0x7f92b909d190>, exit_status=1, command=b'time...57306 46} on the storage, file: pbmPitr/rs1/20240126/20240126082145-4.20240126082146-46.oplog, error: file is empty\n')
n = <testinfra.host.Host docker://rscfg01>, timeout = 1706257461.9419887

    def make_restore(self, name, **kwargs):
        if self.layout == "sharded":
            client = pymongo.MongoClient(self.connection)
            result = client.admin.command("balancerStop")
            client.close()
            Cluster.log("Stopping balancer: " + str(result))
            self.stop_mongos()
        self.stop_arbiters()
        n = testinfra.get_host("docker://" + self.pbm_cli)
        timeout = time.time() + 60
    
        while True:
            if not self.get_status()['running']:
                break
            if time.time() > timeout:
                assert False, "Cannot start restore, another operation running"
            time.sleep(1)
        Cluster.log("Restore started")
        result = n.run('timeout 240 pbm restore ' + name + ' --wait')
        if result.rc == 124:
            # try to catch possible failures if timeout exceeded
            for host in self.mongod_hosts:
                try:
                    container = docker.from_env().containers.get(host)
                    get_logs = container.exec_run(
                        'cat /var/lib/mongo/pbm.restore.log', stderr=False)
                    if get_logs.exit_code == 0:
                        Cluster.log(
                            "!!!!Possible failure on {}, file pbm.restore.log was found:".format(host))
                        Cluster.log(get_logs.output.decode('utf-8'))
                except docker.errors.APIError:
                    pass
            assert False, "Timeout for restore exceeded"
        elif result.rc == 0:
            Cluster.log(result.stdout)
        else:
>           assert False, result.stdout + result.stderr
E           AssertionError: Starting restore 2024-01-26T08:23:22.141408241Z to point-in-time 2024-01-26T08:22:05 from '2024-01-26T08:18:54Z'..Error: failed to ensure chunk {1706257305 4}.{1706257306 46} on the storage, file: pbmPitr/rs1/20240126/20240126082145-4.20240126082146-46.oplog, error: file is empty
E           - Restore on replicaset "rscfg" in state: running
E           - Restore on replicaset "rs2" in state: running
E           - Restore on replicaset "rs1" in state: error: failed to ensure chunk {1706257305 4}.{1706257306 46} on the storage, file: pbmPitr/rs1/20240126/20240126082145-4.20240126082146-46.oplog, error: file is empty

cluster.py:450: AssertionError

start_cluster = True, cluster = <cluster.Cluster object at 0x7f92ab331650>
newcluster = <cluster.Cluster object at 0x7f92ab332b50>

    @pytest.mark.testcase(test_case_key="T208", test_step_key=1)
    @pytest.mark.timeout(600,func_only=True)
    def test_logical(start_cluster,cluster,newcluster):
        cluster.check_pbm_status()
        pymongo.MongoClient(cluster.connection)["test"]["test"].insert_many(documents)
        backup=cluster.make_backup("logical")
        cluster.destroy()
    
        newcluster.make_resync()
>       newcluster.make_restore(backup,check_pbm_status=True)

test_fresh_sharded.py:77: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <cluster.Cluster object at 0x7f92ab332b50>, name = '2024-01-26T08:25:04Z'
kwargs = {'check_pbm_status': True}
client = MongoClient(host=['newmongos:27017'], document_class=dict, tz_aware=False, connect=True)
result = CommandResult(backend=<testinfra.backend.docker.DockerBackend object at 0x7f92b54360d0>, exit_status=1, command=b'time...024-01-26T08:25:04Z --wait', _stdout=b'', _stderr=b"Error: backup '2024-01-26T08:25:04Z' didn't finish successfully\n")
n = <testinfra.host.Host docker://newrscfg01>, timeout = 1706257602.0151296

    def make_restore(self, name, **kwargs):
        if self.layout == "sharded":
            client = pymongo.MongoClient(self.connection)
            result = client.admin.command("balancerStop")
            client.close()
            Cluster.log("Stopping balancer: " + str(result))
            self.stop_mongos()
        self.stop_arbiters()
        n = testinfra.get_host("docker://" + self.pbm_cli)
        timeout = time.time() + 60
    
        while True:
            if not self.get_status()['running']:
                break
            if time.time() > timeout:
                assert False, "Cannot start restore, another operation running"
            time.sleep(1)
        Cluster.log("Restore started")
        result = n.run('timeout 240 pbm restore ' + name + ' --wait')
        if result.rc == 124:
            # try to catch possible failures if timeout exceeded
            for host in self.mongod_hosts:
                try:
                    container = docker.from_env().containers.get(host)
                    get_logs = container.exec_run(
                        'cat /var/lib/mongo/pbm.restore.log', stderr=False)
                    if get_logs.exit_code == 0:
                        Cluster.log(
                            "!!!!Possible failure on {}, file pbm.restore.log was found:".format(host))
                        Cluster.log(get_logs.output.decode('utf-8'))
                except docker.errors.APIError:
                    pass
            assert False, "Timeout for restore exceeded"
        elif result.rc == 0:
            Cluster.log(result.stdout)
        else:
>           assert False, result.stdout + result.stderr
E           AssertionError: Error: backup '2024-01-26T08:25:04Z' didn't finish successfully

cluster.py:450: AssertionError

start_cluster = True, cluster = <cluster.Cluster object at 0x7f92ab32a210>
newcluster = <cluster.Cluster object at 0x7f92ab32a790>

    @pytest.mark.testcase(test_case_key="T211", test_step_key=1)
    @pytest.mark.timeout(600,func_only=True)
    def test_logical(start_cluster,cluster,newcluster):
        cluster.check_pbm_status()
        pymongo.MongoClient(cluster.connection)["test"]["test"].insert_many(documents)
        backup=cluster.make_backup("logical")
        backup = backup + ' --replset-remapping="newrs1=rs1,newrs2=rs2,newrscfg=rscfg"'
        cluster.destroy()
    
        newcluster.make_resync()
>       newcluster.make_restore(backup,check_pbm_status=True)

test_remap_sharded.py:76: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <cluster.Cluster object at 0x7f92ab32a790>
name = '2024-01-26T08:30:09Z --replset-remapping="newrs1=rs1,newrs2=rs2,newrscfg=rscfg"'
kwargs = {'check_pbm_status': True}
client = MongoClient(host=['newmongos:27017'], document_class=dict, tz_aware=False, connect=True)
result = CommandResult(backend=<testinfra.backend.docker.DockerBackend object at 0x7f92b54360d0>, exit_status=1, command=b'time...rs2,newrscfg=rscfg" --wait', _stdout=b'', _stderr=b"Error: backup '2024-01-26T08:30:09Z' didn't finish successfully\n")
n = <testinfra.host.Host docker://newrscfg01>, timeout = 1706257906.643203

    def make_restore(self, name, **kwargs):
        if self.layout == "sharded":
            client = pymongo.MongoClient(self.connection)
            result = client.admin.command("balancerStop")
            client.close()
            Cluster.log("Stopping balancer: " + str(result))
            self.stop_mongos()
        self.stop_arbiters()
        n = testinfra.get_host("docker://" + self.pbm_cli)
        timeout = time.time() + 60
    
        while True:
            if not self.get_status()['running']:
                break
            if time.time() > timeout:
                assert False, "Cannot start restore, another operation running"
            time.sleep(1)
        Cluster.log("Restore started")
        result = n.run('timeout 240 pbm restore ' + name + ' --wait')
        if result.rc == 124:
            # try to catch possible failures if timeout exceeded
            for host in self.mongod_hosts:
                try:
                    container = docker.from_env().containers.get(host)
                    get_logs = container.exec_run(
                        'cat /var/lib/mongo/pbm.restore.log', stderr=False)
                    if get_logs.exit_code == 0:
                        Cluster.log(
                            "!!!!Possible failure on {}, file pbm.restore.log was found:".format(host))
                        Cluster.log(get_logs.output.decode('utf-8'))
                except docker.errors.APIError:
                    pass
            assert False, "Timeout for restore exceeded"
        elif result.rc == 0:
            Cluster.log(result.stdout)
        else:
>           assert False, result.stdout + result.stderr
E           AssertionError: Error: backup '2024-01-26T08:30:09Z' didn't finish successfully

cluster.py:450: AssertionError

start_cluster = True, cluster = <cluster.Cluster object at 0x7f92b88118d0>

    @pytest.mark.timeout(300,func_only=True)
    def test_logical(start_cluster,cluster):
        cluster.check_pbm_status()
        pymongo.MongoClient(cluster.connection)["test"]["test"].insert_many(documents)
        pymongo.MongoClient(cluster.connection)["test"]["test1"].insert_many(documents)
        backup_partial=cluster.make_backup("logical --ns=test.test")
        backup_full=cluster.make_backup("logical")
        pymongo.MongoClient(cluster.connection).drop_database('test')
        cluster.make_restore(backup_partial,check_pbm_status=True)
        assert pymongo.MongoClient(cluster.connection)["test"]["test"].count_documents({}) == len(documents)
        assert pymongo.MongoClient(cluster.connection)["test"]["test1"].count_documents({}) == 0
        pymongo.MongoClient(cluster.connection).drop_database('test')
>       cluster.make_restore(backup_full,check_pbm_status=True)

test_replicaset.py:50: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <cluster.Cluster object at 0x7f92b88118d0>, name = '2024-01-26T08:31:34Z'
kwargs = {'check_pbm_status': True}
result = CommandResult(backend=<testinfra.backend.docker.DockerBackend object at 0x7f92b9166b90>, exit_status=1, command=b'time...024-01-26T08:31:34Z --wait', _stdout=b'', _stderr=b"Error: backup '2024-01-26T08:31:34Z' didn't finish successfully\n")
n = <testinfra.host.Host docker://rs101>, timeout = 1706257981.9942179

    def make_restore(self, name, **kwargs):
        if self.layout == "sharded":
            client = pymongo.MongoClient(self.connection)
            result = client.admin.command("balancerStop")
            client.close()
            Cluster.log("Stopping balancer: " + str(result))
            self.stop_mongos()
        self.stop_arbiters()
        n = testinfra.get_host("docker://" + self.pbm_cli)
        timeout = time.time() + 60
    
        while True:
            if not self.get_status()['running']:
                break
            if time.time() > timeout:
                assert False, "Cannot start restore, another operation running"
            time.sleep(1)
        Cluster.log("Restore started")
        result = n.run('timeout 240 pbm restore ' + name + ' --wait')
        if result.rc == 124:
            # try to catch possible failures if timeout exceeded
            for host in self.mongod_hosts:
                try:
                    container = docker.from_env().containers.get(host)
                    get_logs = container.exec_run(
                        'cat /var/lib/mongo/pbm.restore.log', stderr=False)
                    if get_logs.exit_code == 0:
                        Cluster.log(
                            "!!!!Possible failure on {}, file pbm.restore.log was found:".format(host))
                        Cluster.log(get_logs.output.decode('utf-8'))
                except docker.errors.APIError:
                    pass
            assert False, "Timeout for restore exceeded"
        elif result.rc == 0:
            Cluster.log(result.stdout)
        else:
>           assert False, result.stdout + result.stderr
E           AssertionError: Error: backup '2024-01-26T08:31:34Z' didn't finish successfully

cluster.py:450: AssertionError

start_cluster = True, cluster = <cluster.Cluster object at 0x7f92ba166dd0>

    @pytest.mark.testcase(test_case_key="T218", test_step_key=1)
    @pytest.mark.timeout(600,func_only=True)
    def test_logical(start_cluster,cluster):
        cluster.check_pbm_status()
        pymongo.MongoClient(cluster.connection)["test"]["test"].insert_many(documents)
        pymongo.MongoClient(cluster.connection)["test"]["test1"].insert_many(documents)
        backup_partial_sharded=cluster.make_backup("logical --ns=test.test")
        backup_partial_unsharded=cluster.make_backup("logical --ns=test.test1")
        backup_full=cluster.make_backup("logical")
        pymongo.MongoClient(cluster.connection).drop_database('test')
        cluster.make_restore(backup_partial_sharded,check_pbm_status=True)
        assert pymongo.MongoClient(cluster.connection)["test"]["test"].count_documents({}) == len(documents)
        assert pymongo.MongoClient(cluster.connection)["test"].command("collstats", "test").get("sharded", False)
>       cluster.make_restore(backup_partial_unsharded,check_pbm_status=True)

test_sharded.py:66: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <cluster.Cluster object at 0x7f92ba166dd0>, name = '2024-01-26T08:33:07Z'
kwargs = {'check_pbm_status': True}
client = MongoClient(host=['mongos:27017'], document_class=dict, tz_aware=False, connect=True)
result = CommandResult(backend=<testinfra.backend.docker.DockerBackend object at 0x7f92b909d190>, exit_status=1, command=b'time...024-01-26T08:33:07Z --wait', _stdout=b'', _stderr=b"Error: backup '2024-01-26T08:33:07Z' didn't finish successfully\n")
n = <testinfra.host.Host docker://rscfg01>, timeout = 1706258098.6431956

    def make_restore(self, name, **kwargs):
        if self.layout == "sharded":
            client = pymongo.MongoClient(self.connection)
            result = client.admin.command("balancerStop")
            client.close()
            Cluster.log("Stopping balancer: " + str(result))
            self.stop_mongos()
        self.stop_arbiters()
        n = testinfra.get_host("docker://" + self.pbm_cli)
        timeout = time.time() + 60
    
        while True:
            if not self.get_status()['running']:
                break
            if time.time() > timeout:
                assert False, "Cannot start restore, another operation running"
            time.sleep(1)
        Cluster.log("Restore started")
        result = n.run('timeout 240 pbm restore ' + name + ' --wait')
        if result.rc == 124:
            # try to catch possible failures if timeout exceeded
            for host in self.mongod_hosts:
                try:
                    container = docker.from_env().containers.get(host)
                    get_logs = container.exec_run(
                        'cat /var/lib/mongo/pbm.restore.log', stderr=False)
                    if get_logs.exit_code == 0:
                        Cluster.log(
                            "!!!!Possible failure on {}, file pbm.restore.log was found:".format(host))
                        Cluster.log(get_logs.output.decode('utf-8'))
                except docker.errors.APIError:
                    pass
            assert False, "Timeout for restore exceeded"
        elif result.rc == 0:
            Cluster.log(result.stdout)
        else:
>           assert False, result.stdout + result.stderr
E           AssertionError: Error: backup '2024-01-26T08:33:07Z' didn't finish successfully

cluster.py:450: AssertionError

start_cluster = True, cluster = <cluster.Cluster object at 0x7f92ba166dd0>

    @pytest.mark.testcase(test_case_key="T194", test_step_key=1)
    @pytest.mark.timeout(600, func_only=True)
    def test_logical_pitr(start_cluster,cluster):
        cluster.check_pbm_status()
        pymongo.MongoClient(cluster.connection)["test"]["test"].insert_many(documents)
        backup_l1=cluster.make_backup("logical")
        cluster.enable_pitr(pitr_extra_args="--set pitr.oplogSpanMin=0.5")
        time.sleep(60)
        # make several following backups and then remove them to check the continuity of PITR timeframe
        pymongo.MongoClient(cluster.connection)["test"]["test2"].insert_many(documents)
        backup_l2=cluster.make_backup("logical")
        time.sleep(60)
        pymongo.MongoClient(cluster.connection)["test"]["test3"].insert_many(documents)
        backup_l3=cluster.make_backup("logical")
        pitr = datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%S")
        backup="--time=" + pitr
        Cluster.log("Time for PITR is: " + pitr)
        time.sleep(60)
        cluster.delete_backup(backup_l2)
>       cluster.delete_backup(backup_l3)

test_sharded.py:96: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <cluster.Cluster object at 0x7f92ba166dd0>, name = '2024-01-26T08:37:46Z'

    def delete_backup(self, name):
        n = testinfra.get_host("docker://" + self.pbm_cli)
>       result = n.check_output('pbm delete-backup -y ' + name)
E       AssertionError: Unexpected exit code 1 for CommandResult(backend=<testinfra.backend.docker.DockerBackend object at 0x7f92b909d190>, exit_status=1, command=b'pbm delete-backup -y 2024-01-26T08:37:46Z', _stdout=b'', _stderr=b'Error: backup cannot be deleted: cannot delete the last PITR base snapshot while PITR is enabled\n')
E       assert 1 == 0
E        +  where 1 = CommandResult(backend=<testinfra.backend.docker.DockerBackend object at 0x7f92b909d190>, exit_status=1, command=b'pbm ...out=b'', _stderr=b'Error: backup cannot be deleted: cannot delete the last PITR base snapshot while PITR is enabled\n').rc

cluster.py:798: AssertionError