CI Summary

assert 100000 == 96800
  +100000
  -96800-self = 

    def test_bulk_round_trip_with_timeouts(self):
        """
        Test bulk import with very short read and write timeout values, this should exercise the
        retry and back-off policies. We cannot check the counts because "SELECT COUNT(*)" could timeout
        on Jenkins making the test flacky.
    
        @jira_ticket CASSANDRA-9302
        """
>       self._test_bulk_round_trip(nodes=1, partitioner="murmur3", num_operations=100000,
                                   configuration_options={'range_request_timeout_in_ms': '200',
                                                          'write_request_timeout_in_ms': '100'},
                                   copy_from_options={'MAXINSERTERRORS': -1},
                                   skip_count_checks=True)

cqlsh_tests/test_cqlsh_copy.py:2514: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = 
nodes = 1, partitioner = 'murmur3', num_operations = 100000, profile = None
stress_table = 'keyspace1.standard1'
configuration_options = {'range_request_timeout_in_ms': '200', 'truncate_request_timeout_in_ms': 60000, 'write_request_timeout_in_ms': '100'}
skip_count_checks = True, copy_to_options = {}
copy_from_options = {'MAXINSERTERRORS': -1}

    def _test_bulk_round_trip(self, nodes, partitioner,
                              num_operations, profile=None,
                              stress_table='keyspace1.standard1',
                              configuration_options=None,
                              skip_count_checks=False,
                              copy_to_options=None,
                              copy_from_options=None):
        """
        Test exporting a large number of rows into a csv file.
    
        If skip_count_checks is True then it means we cannot use "SELECT COUNT(*)" as it may time out but
        it also means that we can be sure that one cassandra-stress operation is one record and hence
        num_records=num_operations.
    
        Perform the following:
        - create the records with cassandra-stress
        - export the records to a csv file
        - truncate the table and import the csv file
        - export the records to another csv file
        - check that the length of the two csv files is the same
    
        Therefore, 3 COPY operations are run in total. Return a list of tuples, containing stdout and stderr
        for all 3 copy operations.
        """
        if configuration_options is None:
            configuration_options = {}
        if copy_to_options is None:
            copy_to_options = {}
    
        # The default truncate timeout of 10 seconds that is set in init_default_config() is not
        # enough for truncating larger tables, see CASSANDRA-11157
        if 'truncate_request_timeout_in_ms' not in configuration_options:
            configuration_options['truncate_request_timeout_in_ms'] = 60000
    
        self.prepare(nodes=nodes, partitioner=partitioner, configuration_options=configuration_options)
    
        ret = []
    
        def create_records():
            if not profile:
                logger.debug('Running stress without any user profile')
                self.node1.stress(['write', 'n={} cl=ALL'.format(num_operations), 'no-warmup', '-rate', 'threads=50'])
            else:
                logger.debug('Running stress with user profile {}'.format(profile))
                self.node1.stress(['user', 'profile={}'.format(profile), 'ops(insert=1)',
                                   'n={} cl=ALL'.format(num_operations), 'no-warmup', '-rate', 'threads=50'])
    
            if skip_count_checks:
                return num_operations
            else:
                count_statement = SimpleStatement("SELECT COUNT(*) FROM {}".format(stress_table), consistency_level=ConsistencyLevel.ALL,
                                                  retry_policy=FlakyRetryPolicy(max_retries=3))
                ret = rows_to_list(self.session.execute(count_statement))[0][0]
                logger.debug('Generated {} records'.format(ret))
                assert ret >= num_operations, 'cassandra-stress did not import enough records'
                return ret
    
        def run_copy_to(filename):
            logger.debug('Exporting to csv file: {}'.format(filename.name))
            start = datetime.datetime.now()
            copy_to_cmd = "CONSISTENCY ALL; COPY {} TO '{}'".format(stress_table, filename.name)
            if copy_to_options:
                copy_to_cmd += ' WITH ' + ' AND '.join('{} = {}'.format(k, v) for k, v in copy_to_options.items())
            logger.debug('Running {}'.format(copy_to_cmd))
            result = self.run_cqlsh(cmds=copy_to_cmd)
            ret.append(result)
            logger.debug("COPY TO took {} to export {} records".format(datetime.datetime.now() - start, num_records))
    
        def run_copy_from(filename):
            logger.debug('Importing from csv file: {}'.format(filename.name))
            start = datetime.datetime.now()
            copy_from_cmd = "COPY {} FROM '{}'".format(stress_table, filename.name)
            if copy_from_options:
                copy_from_cmd += ' WITH ' + ' AND '.join('{} = {}'.format(k, v) for k, v in copy_from_options.items())
            logger.debug('Running {}'.format(copy_from_cmd))
            result = self.run_cqlsh(cmds=copy_from_cmd)
            ret.append(result)
            logger.debug("COPY FROM took {} to import {} records".format(datetime.datetime.now() - start, num_records))
    
        num_records = create_records()
    
        # Copy to the first csv files
        tempfile1 = self.get_temp_file()
        run_copy_to(tempfile1)
    
        # check all records generated were exported
        with io.open(tempfile1.name, encoding="utf-8", newline='') as csvfile:
            assert num_records == sum(1 for _ in csv.reader(csvfile, quotechar='"', escapechar='\\'))
    
        # import records from the first csv file
        logger.debug('Truncating {}...'.format(stress_table))
        self.session.execute("TRUNCATE {}".format(stress_table))
        run_copy_from(tempfile1)
    
        # export again to a second csv file
        tempfile2 = self.get_temp_file()
        run_copy_to(tempfile2)
    
        # check the length of both files is the same to ensure all exported records were imported
>       assert sum(1 for _ in open(tempfile1.name)) == sum(1 for _ in open(tempfile2.name))
E       assert 100000 == 96800
E         +100000
E         -96800

cqlsh_tests/test_cqlsh_copy.py:2456: AssertionError

cassandra.OperationTimedOut: errors={'127.0.0.2:9042': 'Client request timeout. See Session.execute[_async](timeout)'}, last_host=127.0.0.2:9042-self = 

    @since('2.1.1', max_version='5.0.x')
    def test_simultaneous_bootstrap(self):
        """
        Attempt to bootstrap two nodes at once, to assert the second bootstrapped node fails, and does not interfere.
    
        Start a one node cluster and run a stress write workload.
        Start up a second node, and wait for the first node to detect it has joined the cluster.
        While the second node is bootstrapping, start a third node. This should fail.
    
        @jira_ticket CASSANDRA-7069
        @jira_ticket CASSANDRA-9484
        """
    
        bootstrap_error = "Other bootstrapping/leaving/moving nodes detected," \
                          " cannot bootstrap while cassandra.consistent.rangemovement is true"
    
        cluster = self.cluster
        cluster.set_environment_variable('CASSANDRA_TOKEN_PREGENERATION_DISABLED', 'True')
        cluster.populate(1)
        cluster.start()
    
        node1, = cluster.nodelist()
    
        node1.stress(['write', 'n=500K', 'no-warmup', '-schema', 'replication(factor=1)',
                      '-rate', 'threads=10'])
    
        node2 = new_node(cluster)
        node2.start()
    
        for _ in range(30):  # wait until node2 shows up
            ntout = node1.nodetool('status').stdout
            if re.search(r'UJ\s+' + node2.ip_addr, ntout):
                break
            time.sleep(0.1)
    
        node3 = new_node(cluster, remote_debug_port='2003')
        try:
            node3.start(wait_other_notice=False, verbose=False)
        except NodeError:
            pass  # node doesn't start as expected
    
        time.sleep(.5)
        node2.watch_log_for("Starting listening for CQL clients")
    
        node3.watch_log_for(bootstrap_error)
    
        session = self.patient_exclusive_cql_connection(node2)
    
        # Repeat the select count(*) query, to help catch
        # bugs like 9484, where count(*) fails at higher
        # data loads.
        for _ in range(5):
>           assert_one(session, "SELECT count(*) from keyspace1.standard1", [500000], cl=ConsistencyLevel.ONE)

bootstrap_test.py:932: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tools/assertions.py:130: in assert_one
    res = session.execute(simple_query)
../cassandra/build/venv/src/cassandra-driver/cassandra/cluster.py:2618: in execute
    return self.execute_async(query, parameters, trace, custom_payload, timeout, execution_profile, paging_state, host, execute_as).result()
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = 

    def result(self):
        """
        Return the final result or raise an Exception if errors were
        encountered.  If the final result or error has not been set
        yet, this method will block until it is set, or the timeout
        set for the request expires.
    
        Timeout is specified in the Session request execution functions.
        If the timeout is exceeded, an :exc:`cassandra.OperationTimedOut` will be raised.
        This is a client-side timeout. For more information
        about server-side coordinator timeouts, see :class:`.policies.RetryPolicy`.
    
        Example usage::
    
            >>> future = session.execute_async("SELECT * FROM mycf")
            >>> # do other stuff...
    
            >>> try:
            ...     rows = future.result()
            ...     for row in rows:
            ...         ... # process results
            ... except Exception:
            ...     log.exception("Operation failed:")
    
        """
        self._event.wait()
        if self._final_result is not _NOT_SET:
            return ResultSet(self, self._final_result)
        else:
>           raise self._final_exception
E           cassandra.OperationTimedOut: errors={'127.0.0.2:9042': 'Client request timeout. See Session.execute[_async](timeout)'}, last_host=127.0.0.2:9042

../cassandra/build/venv/src/cassandra-driver/cassandra/cluster.py:4894: OperationTimedOut