Ejemplo n.º 1
0
        public static TokenMap Build(String partitioner, Dictionary <IPAddress, DictSet <string> > allTokens)
        {
            TokenFactory factory = TokenFactory.GetFactory(partitioner);

            if (factory == null)
            {
                return(null);
            }

            Dictionary <IToken, DictSet <IPAddress> > tokenToCassandraClusterHosts = new Dictionary <IToken, DictSet <IPAddress> >();
            DictSet <IToken> allSorted = new DictSet <IToken>();

            foreach (var entry in allTokens)
            {
                var cassandraClusterHost = entry.Key;
                foreach (string tokenStr in entry.Value)
                {
                    try
                    {
                        IToken t = factory.Parse(tokenStr);
                        allSorted.Add(t);
                        if (!tokenToCassandraClusterHosts.ContainsKey(t))
                        {
                            tokenToCassandraClusterHosts.Add(t, new DictSet <IPAddress>());
                        }
                        tokenToCassandraClusterHosts[t].Add(cassandraClusterHost);
                    }
                    catch (ArgumentException e)
                    {
                        // If we failed parsing that token, skip it
                    }
                }
            }
            return(new TokenMap(factory, tokenToCassandraClusterHosts, new List <IToken>(allSorted)));
        }
Ejemplo n.º 2
0
        /// <summary>
        ///  Returns the hosts to use for a new query. <p> The returned plan will first
        ///  return replicas (whose <code>HostDistance</code> for the child policy is
        ///  <code>Local</code>) for the query if it can determine them (i.e. mainly if
        ///  <code>query.getRoutingKey()</code> is not <code>null</code>). Following what
        ///  it will return the plan of the child policy.</p>
        /// </summary>
        /// <param name="query"> the query for which to build the plan. </param>
        ///
        /// <returns>the new query plan.</returns>
        public IEnumerable <Host> NewQueryPlan(Query query)
        {
            var routingKey = query == null ? null : query.RoutingKey;

            if (routingKey == null)
            {
                foreach (var iter in _childPolicy.NewQueryPlan(null))
                {
                    yield return(iter);
                }
                yield break;
            }

            var replicas = _cluster.Metadata.GetReplicas(routingKey.RawRoutingKey);

            if (replicas.Count == 0)
            {
                foreach (var iter in _childPolicy.NewQueryPlan(query))
                {
                    yield return(iter);
                }
                yield break;
            }

            var iterator = replicas.GetEnumerator();

            while (iterator.MoveNext())
            {
                var host = _cluster.Metadata.GetHost(iterator.Current);
                if (host != null && host.IsConsiderablyUp && _childPolicy.Distance(host) == HostDistance.Local)
                {
                    yield return(host);
                }
            }

            var childIterator  = _childPolicy.NewQueryPlan(query);
            var remoteChildren = new DictSet <Host>();

            foreach (var host in childIterator)
            {
                if (!replicas.Contains(host.Address))
                {
                    if (_childPolicy.Distance(host) != HostDistance.Local)
                    {
                        remoteChildren.Add(host);
                    }
                    else
                    {
                        yield return(host);
                    }
                }
            }

            foreach (var host in remoteChildren)
            {
                yield return(host);
            }
        }
        internal bool WaitForSchemaAgreement(IPAddress forHost = null)
        {
            var  start   = DateTimeOffset.Now;
            long elapsed = 0;

            while (elapsed < MaxSchemaAgreementWaitMs)
            {
                var versions = new DictSet <Guid>();


                IPAddress queriedHost;

                if (forHost == null)
                {
                    using (var rowset = _session.Query(SelectSchemaPeers, ConsistencyLevel.Default))
                    {
                        queriedHost = rowset.QueriedHost;
                        foreach (var row in rowset.GetRows())
                        {
                            if (row.IsNull("peer") || row.IsNull("schema_version"))
                            {
                                continue;
                            }

                            Host peer = _cluster.Metadata.GetHost(row.GetValue <IPEndPoint>("peer").Address);
                            if (peer != null && peer.IsConsiderablyUp)
                            {
                                versions.Add(row.GetValue <Guid>("schema_version"));
                            }
                        }
                    }
                }
                else
                {
                    queriedHost = forHost;
                    var localhost = _cluster.Metadata.GetHost(queriedHost);
                    var iterLiof  = new List <Host>()
                    {
                        localhost
                    }.GetEnumerator();
                    iterLiof.MoveNext();
                    List <IPAddress> tr = new List <IPAddress>();
                    Dictionary <IPAddress, Exception> exx = new Dictionary <IPAddress, Exception>();
                    var cn = _session.Connect(null, iterLiof, tr, exx);

                    using (var outp = cn.Query(SelectSchemaPeers, ConsistencyLevel.Default, false))
                    {
                        if (outp is OutputRows)
                        {
                            var rowset = new CqlRowSet((outp as OutputRows), null, false);
                            foreach (var row in rowset.GetRows())
                            {
                                if (row.IsNull("peer") || row.IsNull("schema_version"))
                                {
                                    continue;
                                }

                                Host peer = _cluster.Metadata.GetHost(row.GetValue <IPEndPoint>("peer").Address);
                                if (peer != null && peer.IsConsiderablyUp)
                                {
                                    versions.Add(row.GetValue <Guid>("schema_version"));
                                }
                            }
                        }
                    }
                }

                {
                    var localhost = _cluster.Metadata.GetHost(queriedHost);
                    var iterLiof  = new List <Host>()
                    {
                        localhost
                    }.GetEnumerator();
                    iterLiof.MoveNext();
                    List <IPAddress> tr = new List <IPAddress>();
                    Dictionary <IPAddress, Exception> exx = new Dictionary <IPAddress, Exception>();
                    var cn = _session.Connect(null, iterLiof, tr, exx);

                    using (var outp = cn.Query(SelectSchemaLocal, ConsistencyLevel.Default, false))
                    {
                        if (outp is OutputRows)
                        {
                            var rowset = new CqlRowSet((outp as OutputRows), null, false);
                            // Update cluster name, DC and rack for the one node we are connected to
                            foreach (var localRow in rowset.GetRows())
                            {
                                if (!localRow.IsNull("schema_version"))
                                {
                                    versions.Add(localRow.GetValue <Guid>("schema_version"));
                                    break;
                                }
                            }
                        }
                    }
                }


                if (versions.Count <= 1)
                {
                    return(true);
                }

                // let's not flood the node too much
                Thread.Sleep(200);
                elapsed = (long)(DateTimeOffset.Now - start).TotalMilliseconds;
            }

            return(false);
        }
        private void RefreshNodeListAndTokenMap()
        {
            _logger.Info("Refreshing NodeList and TokenMap..");
            // Make sure we're up to date on nodes and tokens
            var    tokenMap    = new Dictionary <IPAddress, DictSet <string> >();
            string partitioner = null;

            var       foundHosts = new List <IPAddress>();
            var       dcs        = new List <string>();
            var       racks      = new List <string>();
            var       allTokens  = new List <DictSet <string> >();
            IPAddress queriedHost;

            using (var rowset = _session.Query(SelectPeers, ConsistencyLevel.Quorum))
            {
                queriedHost = rowset.QueriedHost;
                foreach (var row in rowset.GetRows())
                {
                    var hstip = row.GetValue <IPEndPoint>("peer").Address;
                    if (hstip != null)
                    {
                        foundHosts.Add(hstip);
                        dcs.Add(row.GetValue <string>("data_center"));
                        racks.Add(row.GetValue <string>("rack"));
                        var col = row.GetValue <IEnumerable <string> >("tokens");
                        if (col == null)
                        {
                            allTokens.Add(new DictSet <string>());
                        }
                        else
                        {
                            allTokens.Add(new DictSet <string>(col));
                        }
                    }
                }
            }

            var localhost = _cluster.Metadata.GetHost(queriedHost);
            var iterLiof  = new List <Host>()
            {
                localhost
            }.GetEnumerator();

            iterLiof.MoveNext();
            List <IPAddress> tr = new List <IPAddress>();
            Dictionary <IPAddress, Exception> exx = new Dictionary <IPAddress, Exception>();
            var cn = _session.Connect(null, iterLiof, tr, exx);

            using (var outp = cn.Query(SelectLocal, ConsistencyLevel.Default, false))
            {
                if (outp is OutputRows)
                {
                    var rowset = new CqlRowSet((outp as OutputRows), null, false);
                    // Update cluster name, DC and rack for the one node we are connected to
                    foreach (var localRow in rowset.GetRows())
                    {
                        var clusterName = localRow.GetValue <string>("cluster_name");
                        if (clusterName != null)
                        {
                            _cluster.Metadata.ClusterName = clusterName;
                        }



                        // In theory host can't be null. However there is no point in risking a NPE in case we
                        // have a race between a node removal and this.
                        if (localhost != null)
                        {
                            localhost.SetLocationInfo(localRow.GetValue <string>("data_center"), localRow.GetValue <string>("rack"));

                            partitioner = localRow.GetValue <string>("partitioner");
                            var tokens = localRow.GetValue <IList <string> >("tokens");
                            if (partitioner != null && tokens.Count > 0)
                            {
                                if (!tokenMap.ContainsKey(localhost.Address))
                                {
                                    tokenMap.Add(localhost.Address, new DictSet <string>());
                                }
                                tokenMap[localhost.Address].AddRange(tokens);
                            }
                        }

                        break; //fetch only one row
                    }
                }
            }

            for (int i = 0; i < foundHosts.Count; i++)
            {
                var host = _cluster.Metadata.GetHost(foundHosts[i]);
                if (host == null)
                {
                    // We don't know that node, add it.
                    host = _cluster.Metadata.AddHost(foundHosts[i]);
                }
                host.SetLocationInfo(dcs[i], racks[i]);

                if (partitioner != null && !allTokens[i].IsEmpty)
                {
                    tokenMap.Add(host.Address, allTokens[i]);
                }
            }

            // Removes all those that seems to have been removed (since we lost the control connection)
            var foundHostsSet = new DictSet <IPAddress>(foundHosts);

            foreach (var host in _cluster.Metadata.AllReplicas())
            {
                if (!host.Equals(queriedHost) && !foundHostsSet.Contains(host))
                {
                    _cluster.Metadata.RemoveHost(host);
                }
            }

            if (partitioner != null)
            {
                _cluster.Metadata.RebuildTokenMap(partitioner, tokenMap);
            }

            _logger.Info("NodeList and TokenMap have been successfully refreshed!");
        }