示例#1
0
 public DistributedHashTable(IDistributedHashTableMaster master, IConnectionPool pool)
 {
     this.master = master;
     this.pool = pool;
     topology = master.GetTopology();
 }
示例#2
0
 private void RefreshTopology()
 {
     topology = master.GetTopology();
 }
        private void StartPendingBackupsForCurrentNode(Topology topology)
        {
            if (Topology == null)
                return;
            if (Interlocked.CompareExchange(ref currentlyReplicatingBackups, 0, 0) != 0)
                return;

            foreach (var segmentToReplicate in topology.Segments
                .Where(x => x.AssignedEndpoint != null)
                .Where(x => x.PendingBackups.Contains(endpoint))
                .GroupBy(x => x.AssignedEndpoint))
            {
                var command = new OnlineSegmentReplicationCommand(
                    segmentToReplicate.Key,
                    segmentToReplicate.ToArray(),
                    ReplicationType.Backup,
                    this,
                    replicationFactory);

                Interlocked.Increment(ref currentlyReplicatingBackups);

                command.Completed += (() => Interlocked.Decrement(ref currentlyReplicatingBackups));

                executer.RegisterForExecution(command);
            }
        }
        private void RemoveMoveMarkerForSegmentsThatWeAreNoLongerResponsibleFor(Topology topology)
        {
            if (Topology == null || topology == null)
                return;

            var removeSegmentsThatWereMovedFromNode =
                (
                    from prev in Topology.Segments
                    join current in topology.Segments on prev.Index equals current.Index
                    where prev.AssignedEndpoint == endpoint && current.AssignedEndpoint != endpoint
                    select new ExtendedRemoveRequest
                    {
                        Key = Constants.MovedSegment + prev.Index,
                        Segment = prev.Index,
                        IsLocal = true
                    }
                ).ToArray();

            if (removeSegmentsThatWereMovedFromNode.Length == 0)
                return;
            Storage.Remove(GetTopologyVersion(), removeSegmentsThatWereMovedFromNode);
        }
        public void Start()
        {
            var assignedSegments = master.Join(endpoint);
            Topology = master.GetTopology();
            var segmentsThatWeAreCatchingUpOnOwnership = assignedSegments
                .Where(x => x.AssignedEndpoint != endpoint)
                .ToArray();
            foreach (var segmentToReplicate in segmentsThatWeAreCatchingUpOnOwnership
                .GroupBy(x => x.AssignedEndpoint))
            {
                executer.RegisterForExecution(
                    new OnlineSegmentReplicationCommand(
                        segmentToReplicate.Key,
                        segmentToReplicate.ToArray(),
                        ReplicationType.Ownership,
                        this,
                        replicationFactory)
                    );
            }

            StartPendingBackupsForCurrentNode(Topology);

            var ownsSegments = assignedSegments.Any(x => x.AssignedEndpoint == endpoint);

            backgroundReplication.Start();
            State = ownsSegments ?
                NodeState.Started :
                NodeState.Starting;
        }
 public void SetTopology(Topology topology)
 {
     RemoveMoveMarkerForSegmentsThatWeAreNoLongerResponsibleFor(topology);
     Topology = topology;
     StartPendingBackupsForCurrentNode(topology);
 }