Don't create Host instances with random host_id

Author: sylwiaszunejko

cassandra/cluster.py

@@ -1464,7 +1464,9 @@ def __init__(self,
             self.schema_event_refresh_window, self.topology_event_refresh_window,
             self.status_event_refresh_window,
             schema_metadata_enabled, token_metadata_enabled,
-            schema_meta_page_size=schema_metadata_page_size)
+            schema_meta_page_size=schema_metadata_page_size,
+            resolved_contact_points=self.endpoints_resolved,
+        )
 
         if client_id is None:
             self.client_id = uuid.uuid4()
@@ -1683,14 +1685,7 @@ def protocol_downgrade(self, host_endpoint, previous_version):
                     "http://datastax.github.io/python-driver/api/cassandra/cluster.html#cassandra.cluster.Cluster.protocol_version", self.protocol_version, new_version, host_endpoint)
         self.protocol_version = new_version
 
-    def _add_resolved_hosts(self):
-        for endpoint in self.endpoints_resolved:
-            host, new = self.add_host(endpoint, signal=False)
-            if new:
-                host.set_up()
-                for listener in self.listeners:
-                    listener.on_add(host)
-
+    def _populate_hosts(self):
         self.profile_manager.populate(
             weakref.proxy(self), self.metadata.all_hosts())
         self.load_balancing_policy.populate(
@@ -1717,17 +1712,10 @@ def connect(self, keyspace=None, wait_for_all_pools=False):
                           self.contact_points, self.protocol_version)
                 self.connection_class.initialize_reactor()
                 _register_cluster_shutdown(self)
-                
-                self._add_resolved_hosts()
 
                 try:
                     self.control_connection.connect()
-
-                    # we set all contact points up for connecting, but we won't infer state after this
-                    for endpoint in self.endpoints_resolved:
-                        h = self.metadata.get_host(endpoint)
-                        if h and self.profile_manager.distance(h) == HostDistance.IGNORED:
-                            h.is_up = None
+                    self._populate_hosts()
 
                     log.debug("Control connection created")
                 except Exception:
@@ -3483,6 +3471,8 @@ class PeersQueryType(object):
     _uses_peers_v2 = True
     _tablets_routing_v1 = False
 
+    _resolved_contact_points = None
+
     # for testing purposes
     _time = time
 
@@ -3492,7 +3482,8 @@ def __init__(self, cluster, timeout,
                  status_event_refresh_window,
                  schema_meta_enabled=True,
                  token_meta_enabled=True,
-                 schema_meta_page_size=1000):
+                 schema_meta_page_size=1000,
+                 resolved_contact_points=None):
         # use a weak reference to allow the Cluster instance to be GC'ed (and
         # shutdown) since implementing __del__ disables the cycle detector
         self._cluster = weakref.proxy(cluster)
@@ -3514,6 +3505,8 @@ def __init__(self, cluster, timeout,
 
         self._event_schedule_times = {}
 
+        self._resolved_contact_points = resolved_contact_points
+
     def connect(self):
         if self._is_shutdown:
             return
@@ -3534,28 +3527,23 @@ def _set_new_connection(self, conn):
         if old:
             log.debug("[control connection] Closing old connection %r, replacing with %r", old, conn)
             old.close()
-    
-    def _connect_host_in_lbp(self):
+
+    def _connect_host(self):
         errors = {}
-        lbp = (
-            self._cluster.load_balancing_policy
-            if self._cluster._config_mode == _ConfigMode.LEGACY else
-            self._cluster._default_load_balancing_policy
-        )
 
-        for host in lbp.make_query_plan():
+        for endpoint in self._resolved_contact_points:
             try:
-                return (self._try_connect(host), None)
+                return (self._try_connect(endpoint), None)
             except ConnectionException as exc:
-                errors[str(host.endpoint)] = exc
-                log.warning("[control connection] Error connecting to %s:", host, exc_info=True)
-                self._cluster.signal_connection_failure(host, exc, is_host_addition=False)
+                errors[str(endpoint)] = exc
+                log.warning("[control connection] Error connecting to %s:", endpoint, exc_info=True)
+                self._cluster.signal_connection_failure(endpoint, exc, is_host_addition=False)
             except Exception as exc:
-                errors[str(host.endpoint)] = exc
-                log.warning("[control connection] Error connecting to %s:", host, exc_info=True)
+                errors[str(endpoint)] = exc
+                log.warning("[control connection] Error connecting to %s:", endpoint, exc_info=True)
             if self._is_shutdown:
                 raise DriverException("[control connection] Reconnection in progress during shutdown")
-        
+
         return (None, errors)
 
     def _reconnect_internal(self):
@@ -3567,43 +3555,44 @@ def _reconnect_internal(self):
         to the exception that was raised when an attempt was made to open
         a connection to that host.
         """
-        (conn, _) = self._connect_host_in_lbp()
+        (conn, _) = self._connect_host()
         if conn is not None:
             return conn
 
         # Try to re-resolve hostnames as a fallback when all hosts are unreachable
         self._cluster._resolve_hostnames()
+        self._resolved_contact_points = self._cluster.endpoints_resolved
 
-        self._cluster._add_resolved_hosts()
+        self._cluster._populate_hosts()
 
-        (conn, errors) = self._connect_host_in_lbp()
+        (conn, errors) = self._connect_host()
         if conn is not None:
             return conn
-        
+
         raise NoHostAvailable("Unable to connect to any servers", errors)
 
-    def _try_connect(self, host):
+    def _try_connect(self, endpoint):
         """
         Creates a new Connection, registers for pushed events, and refreshes
         node/token and schema metadata.
         """
-        log.debug("[control connection] Opening new connection to %s", host)
+        log.debug("[control connection] Opening new connection to %s", endpoint)
 
         while True:
             try:
-                connection = self._cluster.connection_factory(host.endpoint, is_control_connection=True)
+                connection = self._cluster.connection_factory(endpoint, is_control_connection=True)
                 if self._is_shutdown:
                     connection.close()
                     raise DriverException("Reconnecting during shutdown")
                 break
             except ProtocolVersionUnsupported as e:
-                self._cluster.protocol_downgrade(host.endpoint, e.startup_version)
+                self._cluster.protocol_downgrade(endpoint, e.startup_version)
             except ProtocolException as e:
                 # protocol v5 is out of beta in C* >=4.0-beta5 and is now the default driver
                 # protocol version. If the protocol version was not explicitly specified,
                 # and that the server raises a beta protocol error, we should downgrade.
                 if not self._cluster._protocol_version_explicit and e.is_beta_protocol_error:
-                    self._cluster.protocol_downgrade(host.endpoint, self._cluster.protocol_version)
+                    self._cluster.protocol_downgrade(endpoint, self._cluster.protocol_version)
                 else:
                     raise
 
@@ -3879,6 +3868,9 @@ def _refresh_node_list_and_token_map(self, connection, preloaded_results=None,
 
                 self._cluster.metadata.update_host(host, old_endpoint=connection.endpoint)
                 connection.original_endpoint = connection.endpoint = host.endpoint
+            else:
+                log.info("Consider local host new found host")
+                peers_result.append(local_row)
         # Check metadata.partitioner to see if we haven't built anything yet. If
         # every node in the cluster was in the contact points, we won't discover
         # any new nodes, so we need this additional check.  (See PYTHON-90)

cassandra/metadata.py

@@ -139,6 +139,9 @@ def export_schema_as_string(self):
     def refresh(self, connection, timeout, target_type=None, change_type=None, fetch_size=None,
                 metadata_request_timeout=None, **kwargs):
 
+        if not self.get_host(connection.original_endpoint):
+            return
+
         server_version = self.get_host(connection.original_endpoint).release_version
         dse_version = self.get_host(connection.original_endpoint).dse_version
         parser = get_schema_parser(connection, server_version, dse_version, timeout, metadata_request_timeout, fetch_size)

cassandra/policies.py

@@ -264,6 +264,9 @@ def populate(self, cluster, hosts):
 
     def distance(self, host):
         dc = self._dc(host)
+        if not self.local_dc:
+            self.local_dc = dc
+            return HostDistance.LOCAL
         if dc == self.local_dc:
             return HostDistance.LOCAL
 

cassandra/pool.py

@@ -176,7 +176,7 @@ def __init__(self, endpoint, conviction_policy_factory, datacenter=None, rack=No
         self.endpoint = endpoint if isinstance(endpoint, EndPoint) else DefaultEndPoint(endpoint)
         self.conviction_policy = conviction_policy_factory(self)
         if not host_id:
-            host_id = uuid.uuid4()
+            raise ValueError("host_id may not be None")
         self.host_id = host_id
         self.set_location_info(datacenter, rack)
         self.lock = RLock()

tests/integration/standard/test_policies.py

@@ -45,9 +45,6 @@ def test_predicate_changes(self):
         external_event = True
         contact_point = DefaultEndPoint("127.0.0.1")
 
-        single_host = {Host(contact_point, SimpleConvictionPolicy)}
-        all_hosts = {Host(DefaultEndPoint("127.0.0.{}".format(i)), SimpleConvictionPolicy) for i in (1, 2, 3)}
-
         predicate = lambda host: host.endpoint == contact_point if external_event else True
         hfp = ExecutionProfile(
             load_balancing_policy=HostFilterPolicy(RoundRobinPolicy(), predicate=predicate)
@@ -62,7 +59,8 @@ def test_predicate_changes(self):
             response = session.execute("SELECT * from system.local WHERE key='local'")
             queried_hosts.update(response.response_future.attempted_hosts)
 
-        assert queried_hosts == single_host
+        assert len(queried_hosts) == 1
+        assert queried_hosts.pop().endpoint == contact_point
 
         external_event = False
         futures = session.update_created_pools()
@@ -72,7 +70,7 @@ def test_predicate_changes(self):
         for _ in range(10):
             response = session.execute("SELECT * from system.local WHERE key='local'")
             queried_hosts.update(response.response_future.attempted_hosts)
-        assert queried_hosts == all_hosts
+        assert len(queried_hosts) == 3
 
 
 class WhiteListRoundRobinPolicyTests(unittest.TestCase):