Example #1
0
    def test_exec_profile_clone(self):

        cluster = Cluster(execution_profiles={EXEC_PROFILE_DEFAULT: ExecutionProfile(), 'one': ExecutionProfile()})
        session = Session(cluster, hosts=[Host("127.0.0.1", SimpleConvictionPolicy)])

        profile_attrs = {'request_timeout': 1,
                         'consistency_level': ConsistencyLevel.ANY,
                         'serial_consistency_level': ConsistencyLevel.SERIAL,
                         'row_factory': tuple_factory,
                         'retry_policy': RetryPolicy(),
                         'load_balancing_policy': default_lbp_factory()}
        reference_attributes = ('retry_policy', 'load_balancing_policy')

        # default and one named
        for profile in (EXEC_PROFILE_DEFAULT, 'one'):
            active = session.get_execution_profile(profile)
            clone = session.execution_profile_clone_update(profile)
            self.assertIsNot(clone, active)

            all_updated = session.execution_profile_clone_update(clone, **profile_attrs)
            self.assertIsNot(all_updated, clone)
            for attr, value in profile_attrs.items():
                self.assertEqual(getattr(clone, attr), getattr(active, attr))
                if attr in reference_attributes:
                    self.assertIs(getattr(clone, attr), getattr(active, attr))
                self.assertNotEqual(getattr(all_updated, attr), getattr(active, attr))

        # cannot clone nonexistent profile
        self.assertRaises(ValueError, session.execution_profile_clone_update, 'DOES NOT EXIST', **profile_attrs)
Example #2
0
    def test_default_serial_consistency_level(self, *_):
        """
        Make sure default_serial_consistency_level passes through to a query message.
        Also make sure Statement.serial_consistency_level overrides the default.

        PR #510
        """
        s = Session(Cluster(protocol_version=4), [Host("127.0.0.1", SimpleConvictionPolicy)])

        # default is None
        self.assertIsNone(s.default_serial_consistency_level)

        sentinel = 1001
        for cl in (None, ConsistencyLevel.LOCAL_SERIAL, ConsistencyLevel.SERIAL, sentinel):
            s.default_serial_consistency_level = cl

            # default is passed through
            f = s.execute_async(query='')
            self.assertEqual(f.message.serial_consistency_level, cl)

            # any non-None statement setting takes precedence
            for cl_override in (ConsistencyLevel.LOCAL_SERIAL, ConsistencyLevel.SERIAL):
                f = s.execute_async(SimpleStatement(query_string='', serial_consistency_level=cl_override))
                self.assertEqual(s.default_serial_consistency_level, cl)
                self.assertEqual(f.message.serial_consistency_level, cl_override)
Example #3
0
    def test_default_serial_consistency_level(self, *_):
        """
        Make sure default_serial_consistency_level passes through to a query message.
        Also make sure Statement.serial_consistency_level overrides the default.

        PR #510
        """
        s = Session(Mock(protocol_version=4), [])

        # default is None
        self.assertIsNone(s.default_serial_consistency_level)

        sentinel = 1001
        for cl in (None, ConsistencyLevel.LOCAL_SERIAL, ConsistencyLevel.SERIAL, sentinel):
            s.default_serial_consistency_level = cl

            # default is passed through
            f = s._create_response_future(query='', parameters=[], trace=False, custom_payload={}, timeout=100)
            self.assertEqual(f.message.serial_consistency_level, cl)

            # any non-None statement setting takes precedence
            for cl_override in (ConsistencyLevel.LOCAL_SERIAL, ConsistencyLevel.SERIAL):
                f = s._create_response_future(SimpleStatement(query_string='', serial_consistency_level=cl_override), parameters=[], trace=False, custom_payload={}, timeout=100)
                self.assertEqual(s.default_serial_consistency_level, cl)
                self.assertEqual(f.message.serial_consistency_level, cl_override)
Example #4
0
    def test_profile_name_value(self):

        internalized_profile = ExecutionProfile(RoundRobinPolicy(), *[object() for _ in range(2)])
        cluster = Cluster(execution_profiles={'by-name': internalized_profile})
        session = Session(cluster, hosts=[Host("127.0.0.1", SimpleConvictionPolicy)])
        self.assertEqual(cluster._config_mode, _ConfigMode.PROFILES)

        rf = session.execute_async("query", execution_profile='by-name')
        self._verify_response_future_profile(rf, internalized_profile)

        by_value = ExecutionProfile(RoundRobinPolicy(), *[object() for _ in range(2)])
        rf = session.execute_async("query", execution_profile=by_value)
        self._verify_response_future_profile(rf, by_value)
Example #5
0
    def test_default_profile(self):
        non_default_profile = ExecutionProfile(RoundRobinPolicy(), *[object() for _ in range(3)])
        cluster = Cluster(execution_profiles={'non-default': non_default_profile})
        session = Session(cluster, hosts=[Host("127.0.0.1", SimpleConvictionPolicy)])

        self.assertEqual(cluster._config_mode, _ConfigMode.PROFILES)

        default_profile = cluster.profile_manager.profiles[EXEC_PROFILE_DEFAULT]
        rf = session.execute_async("query")
        self._verify_response_future_profile(rf, default_profile)

        rf = session.execute_async("query", execution_profile='non-default')
        self._verify_response_future_profile(rf, non_default_profile)
Example #6
0
    def test_statement_params_override_legacy(self):
        cluster = Cluster(load_balancing_policy=RoundRobinPolicy(), default_retry_policy=DowngradingConsistencyRetryPolicy())
        self.assertEqual(cluster._config_mode, _ConfigMode.LEGACY)
        session = Session(cluster, hosts=[Host("127.0.0.1", SimpleConvictionPolicy)])

        ss = SimpleStatement("query", retry_policy=DowngradingConsistencyRetryPolicy(),
                             consistency_level=ConsistencyLevel.ALL, serial_consistency_level=ConsistencyLevel.SERIAL)
        my_timeout = 1.1234

        self.assertNotEqual(ss.retry_policy.__class__, cluster.default_retry_policy)
        self.assertNotEqual(ss.consistency_level, session.default_consistency_level)
        self.assertNotEqual(ss._serial_consistency_level, session.default_serial_consistency_level)
        self.assertNotEqual(my_timeout, session.default_timeout)

        rf = session.execute_async(ss, timeout=my_timeout)
        expected_profile = ExecutionProfile(load_balancing_policy=cluster.load_balancing_policy, retry_policy=ss.retry_policy,
                                            request_timeout=my_timeout, consistency_level=ss.consistency_level,
                                            serial_consistency_level=ss._serial_consistency_level)
        self._verify_response_future_profile(rf, expected_profile)
Example #7
0
    def test_session_host_parameter(self):
        """
        Test for protocol negotiation

        Very that NoHostAvailable is risen in Session.__init__ when there are no valid connections and that
        no error is arisen otherwise, despite maybe being some invalid hosts

        @since 3.9
        @jira_ticket PYTHON-665
        @expected_result NoHostAvailable when the driver is unable to connect to a valid host,
        no exception otherwise

        @test_category connection
        """
        with self.assertRaises(NoHostAvailable):
            Session(Cluster(protocol_version=PROTOCOL_VERSION), [])
        with self.assertRaises(NoHostAvailable):
            Session(Cluster(protocol_version=PROTOCOL_VERSION), [Host("1.2.3.4", SimpleConvictionPolicy)])
        session = Session(Cluster(protocol_version=PROTOCOL_VERSION), [Host(x, SimpleConvictionPolicy) for x in
                                      ("127.0.0.1", "127.0.0.2", "1.2.3.4")])
        session.shutdown()
Example #8
0
    def test_statement_params_override_profile(self):
        non_default_profile = ExecutionProfile(RoundRobinPolicy(), *[object() for _ in range(2)])
        cluster = Cluster(execution_profiles={'non-default': non_default_profile})
        session = Session(cluster, hosts=[Host("127.0.0.1", SimpleConvictionPolicy)])

        self.assertEqual(cluster._config_mode, _ConfigMode.PROFILES)

        rf = session.execute_async("query", execution_profile='non-default')

        ss = SimpleStatement("query", retry_policy=DowngradingConsistencyRetryPolicy(),
                             consistency_level=ConsistencyLevel.ALL, serial_consistency_level=ConsistencyLevel.SERIAL)
        my_timeout = 1.1234

        self.assertNotEqual(ss.retry_policy.__class__, rf._load_balancer.__class__)
        self.assertNotEqual(ss.consistency_level, rf.message.consistency_level)
        self.assertNotEqual(ss._serial_consistency_level, rf.message.serial_consistency_level)
        self.assertNotEqual(my_timeout, rf.timeout)

        rf = session.execute_async(ss, timeout=my_timeout, execution_profile='non-default')
        expected_profile = ExecutionProfile(non_default_profile.load_balancing_policy, ss.retry_policy,
                                            ss.consistency_level, ss._serial_consistency_level, my_timeout, non_default_profile.row_factory)
        self._verify_response_future_profile(rf, expected_profile)
Example #9
0
 def test_no_legacy_with_profile(self):
     cluster_init = Cluster(execution_profiles={'name': ExecutionProfile()})
     cluster_add = Cluster()
     cluster_add.add_execution_profile('name', ExecutionProfile())
     # for clusters with profiles added either way...
     for cluster in (cluster_init, cluster_init):
         # don't allow legacy parameters set
         for attr, value in (('default_retry_policy', RetryPolicy()),
                             ('load_balancing_policy', default_lbp_factory())):
             self.assertRaises(ValueError, setattr, cluster, attr, value)
         session = Session(cluster, hosts=[Host("127.0.0.1", SimpleConvictionPolicy)])
         for attr, value in (('default_timeout', 1),
                             ('default_consistency_level', ConsistencyLevel.ANY),
                             ('default_serial_consistency_level', ConsistencyLevel.SERIAL),
                             ('row_factory', tuple_factory)):
             self.assertRaises(ValueError, setattr, session, attr, value)
Example #10
0
 def test_default_legacy(self):
     cluster = Cluster(load_balancing_policy=RoundRobinPolicy(), default_retry_policy=DowngradingConsistencyRetryPolicy())
     self.assertEqual(cluster._config_mode, _ConfigMode.LEGACY)
     session = Session(cluster, hosts=[Host("127.0.0.1", SimpleConvictionPolicy)])
     session.default_timeout = 3.7
     session.default_consistency_level = ConsistencyLevel.ALL
     session.default_serial_consistency_level = ConsistencyLevel.SERIAL
     rf = session.execute_async("query")
     expected_profile = ExecutionProfile(cluster.load_balancing_policy, cluster.default_retry_policy,
                                         session.default_consistency_level, session.default_serial_consistency_level,
                                         session.default_timeout, session.row_factory)
     self._verify_response_future_profile(rf, expected_profile)
Example #11
0
    def test_default_profile(self):
        non_default_profile = ExecutionProfile(RoundRobinPolicy(), *[object() for _ in range(2)])
        cluster = Cluster(execution_profiles={'non-default': non_default_profile})
        session = Session(cluster, hosts=[Host("127.0.0.1", SimpleConvictionPolicy)])

        self.assertEqual(cluster._config_mode, _ConfigMode.PROFILES)

        default_profile = session.get_execution_profile(EXEC_PROFILE_DEFAULT)
        rf = session.execute_async("query")
        self._verify_response_future_profile(rf, default_profile)

        rf = session.execute_async("query", execution_profile='non-default')
        self._verify_response_future_profile(rf, non_default_profile)

        for name, ep in six.iteritems(cluster.profile_manager.profiles):
            self.assertEqual(ep, session.get_execution_profile(name))

        # invalid ep
        with self.assertRaises(ValueError):
            session.get_execution_profile('non-existent')
Example #12
0
    def test_no_profile_with_legacy(self):
        # don't construct with both
        self.assertRaises(ValueError,
                          Cluster,
                          load_balancing_policy=RoundRobinPolicy(),
                          execution_profiles={'a': ExecutionProfile()})
        self.assertRaises(
            ValueError,
            Cluster,
            default_retry_policy=DowngradingConsistencyRetryPolicy(),
            execution_profiles={'a': ExecutionProfile()})
        self.assertRaises(
            ValueError,
            Cluster,
            load_balancing_policy=RoundRobinPolicy(),
            default_retry_policy=DowngradingConsistencyRetryPolicy(),
            execution_profiles={'a': ExecutionProfile()})

        # can't add after
        cluster = Cluster(load_balancing_policy=RoundRobinPolicy())
        self.assertRaises(ValueError, cluster.add_execution_profile, 'name',
                          ExecutionProfile())

        # session settings lock out profiles
        cluster = Cluster()
        session = Session(cluster,
                          hosts=[Host("127.0.0.1", SimpleConvictionPolicy)])
        for attr, value in (('default_timeout',
                             1), ('default_consistency_level',
                                  ConsistencyLevel.ANY),
                            ('default_serial_consistency_level',
                             ConsistencyLevel.SERIAL), ('row_factory',
                                                        tuple_factory)):
            cluster._config_mode = _ConfigMode.UNCOMMITTED
            setattr(session, attr, value)
            self.assertRaises(ValueError, cluster.add_execution_profile,
                              'name' + attr, ExecutionProfile())

        # don't accept profile
        self.assertRaises(ValueError,
                          session.execute_async,
                          "query",
                          execution_profile='some name here')
    def save(self, session: Session, prep_insert_statement: PreparedStatement, data):

        if data is None:
            raise ValueError("Cannot save None data to Cassandra.")

        for channel_data in data:
            channel_name = channel_data[0]
            self.data_cache[channel_name].append(channel_data)

        self.cache_counter += 1

        if self.cache_counter < 100:
            return len(self.future_cache)

        def success_insert(results, future, pulse_id, channel_name):
            self.future_cache.remove(future)

            _logger.debug("Inserted pulse_id=%s for channel_name=%s", pulse_id, channel_name)

        def failed_insert(e, future, pulse_id, channel_name):
            self.future_cache.remove(future)

            _logger.error("ERRRO IN %s. %s", channel_name, e)

        for channel_name, data in self.data_cache.items():
            batch = BatchStatement(batch_type=BatchType.UNLOGGED)

            for pulse_data in data:
                batch.add(prep_insert_statement, pulse_data)

            future = session.execute_async(batch)
            future.add_callbacks(callback=success_insert, callback_args=(future, 1, channel_name),
                                 errback=failed_insert, errback_args=(future, 1, channel_name))

            self.future_cache.add(future)

        self.data_cache.clear()
        self.cache_counter = 0

        return len(self.future_cache)
Example #14
0
    def test_recursion_limited(self):
        """
        Verify that recursion is controlled when raise_on_first_error=False and something is wrong with the query.

        PYTHON-585
        """
        max_recursion = sys.getrecursionlimit()
        s = Session(Cluster(), [Host("127.0.0.1", SimpleConvictionPolicy)])
        self.assertRaises(TypeError,
                          execute_concurrent_with_args,
                          s,
                          "doesn't matter", [('param', )] * max_recursion,
                          raise_on_first_error=True)

        results = execute_concurrent_with_args(
            s,
            "doesn't matter", [('param', )] * max_recursion,
            raise_on_first_error=False)  # previously
        self.assertEqual(len(results), max_recursion)
        for r in results:
            self.assertFalse(r[0])
            self.assertIsInstance(r[1], TypeError)
Example #15
0
    def test_default_serial_consistency_level(self, *_):
        """
        Make sure default_serial_consistency_level passes through to a query message.
        Also make sure Statement.serial_consistency_level overrides the default.

        PR #510
        """
        s = Session(Cluster(protocol_version=4),
                    [Host("127.0.0.1", SimpleConvictionPolicy)])

        # default is None
        self.assertIsNone(s.default_serial_consistency_level)

        # Should fail
        with self.assertRaises(ValueError):
            s.default_serial_consistency_level = ConsistencyLevel.ANY
        with self.assertRaises(ValueError):
            s.default_serial_consistency_level = 1001

        for cl in (None, ConsistencyLevel.LOCAL_SERIAL,
                   ConsistencyLevel.SERIAL):
            s.default_serial_consistency_level = cl

            # default is passed through
            f = s.execute_async(query='')
            self.assertEqual(f.message.serial_consistency_level, cl)

            # any non-None statement setting takes precedence
            for cl_override in (ConsistencyLevel.LOCAL_SERIAL,
                                ConsistencyLevel.SERIAL):
                f = s.execute_async(
                    SimpleStatement(query_string='',
                                    serial_consistency_level=cl_override))
                self.assertEqual(s.default_serial_consistency_level, cl)
                self.assertEqual(f.message.serial_consistency_level,
                                 cl_override)
Example #16
0
    def test_session_host_parameter(self):
        """
        Test for protocol negotiation

        Very that NoHostAvailable is risen in Session.__init__ when there are no valid connections and that
        no error is arisen otherwise, despite maybe being some invalid hosts

        @since 3.9
        @jira_ticket PYTHON-665
        @expected_result NoHostAvailable when the driver is unable to connect to a valid host,
        no exception otherwise

        @test_category connection
        """
        with self.assertRaises(NoHostAvailable):
            Session(Cluster(protocol_version=PROTOCOL_VERSION), [])
        with self.assertRaises(NoHostAvailable):
            Session(Cluster(protocol_version=PROTOCOL_VERSION), [Host("1.2.3.4", SimpleConvictionPolicy)])
        session = Session(Cluster(protocol_version=PROTOCOL_VERSION), [Host(x, SimpleConvictionPolicy) for x in
                                      ("127.0.0.1", "127.0.0.2", "1.2.3.4")])
        session.shutdown()
Example #17
0
def initialize_measurements_table(session: Session, keyspace: str, table: str):
    session.execute((f"CREATE TABLE IF NOT EXISTS {keyspace}.{table} "
                     "(name text, timestamp timestamp, value double, "
                     "PRIMARY KEY (name, timestamp)) "
                     "WITH CLUSTERING ORDER BY (timestamp DESC)"))
Example #18
0
 def create_keyspace(self, session: Session) -> None:
     session.execute("""
     CREATE KEYSPACE IF NOT EXISTS """ + self.KEYSPACE + """
     WITH replication = { 'class': 'SimpleStrategy', 'replication_factor': '1' }
     """)
def create_views(session: Session, views: list) -> None:
    for view in views:
        session.execute(view)
Example #20
0
def get_table_size(session: Session, keyspace: str, table: str) -> int:
    cql = SimpleStatement(f"select count(*) from {keyspace}.{table};")

    return session.execute(cql, timeout=30).one()["count"]
Example #21
0
 def _new_session(self, keyspace):
     session = Session(self, self.metadata.all_hosts(), keyspace)
     self._session_register_user_types(session)
     self.sessions.add(session)
     return session
Example #22
0
def get_values_from_band(session: Session, band: str) -> ResultSet:
    return session.execute("select * from " + config.KEY_SPACE + "." + band)
 async def _execute_query_async(session: Session, query, parameters=None):
     cassandra_future = session.execute_async(query, parameters)
     asyncio_future = asyncio.Future()
     cassandra_future.add_callbacks(asyncio_future.set_result,
                                    asyncio_future.set_exception)
     return await asyncio_future
Example #24
0
def get_data_frame_no_parameter(session: Session,
                                prepared_query: str) -> pd.DataFrame:
    return session.execute(prepared_query)._current_rows
Example #25
0
def create_keyspace(session: Session, keyspace: str = 'insight') -> None:
    session.execute(
        "CREATE KEYSPACE IF NOT EXISTS " + keyspace +
        " WITH replication = {'class':'SimpleStrategy', 'replication_factor' : 3};"
    )
Example #26
0
def create_tables(tables: list, session: Session) -> None:
    for table in tables:
        session.execute(table)
Example #27
0
def get_data_frame(session: Session, prepared_query: PreparedStatement,
                   user: str) -> pd.DataFrame:
    return session.execute(prepared_query, (user, ))._current_rows
Example #28
0
def initialize_keyspace(session: Session, name: str, replication: int = 1):
    session.execute((
        f"CREATE KEYSPACE IF NOT EXISTS {name} "
        "WITH replication = "
        f"{{'class': 'SimpleStrategy', 'replication_factor': '{replication}'}}"
    ))