placement: add manager and FitRegion interface

pkg/mock/mockcluster/mockcluster.go

@@ -25,6 +25,7 @@ import (
 	"github.com/pingcap/pd/pkg/mock/mockoption"
 	"github.com/pingcap/pd/server/core"
 	"github.com/pingcap/pd/server/namespace"
+	"github.com/pingcap/pd/server/schedule/placement"
 	"github.com/pingcap/pd/server/statistics"
 	"go.uber.org/zap"
 )
@@ -34,6 +35,7 @@ type Cluster struct {
 	*core.BasicCluster
 	*mockid.IDAllocator
 	*mockoption.ScheduleOptions
+	*placement.RuleManager
 	*statistics.HotCache
 	*statistics.StoresStats
 	ID uint64
@@ -114,6 +116,11 @@ func (mc *Cluster) AllocPeer(storeID uint64) (*metapb.Peer, error) {
 	return peer, nil
 }
 
+// FitRegion fits a region to the rules it matches.
+func (mc *Cluster) FitRegion(region *core.RegionInfo) *placement.RegionFit {
+	return mc.RuleManager.FitRegion(mc.BasicCluster, region)
+}
+
 // SetStoreUp sets store state to be up.
 func (mc *Cluster) SetStoreUp(storeID uint64) {
 	store := mc.GetStore(storeID)

server/cluster.go

@@ -36,6 +36,7 @@ import (
 	syncer "github.com/pingcap/pd/server/region_syncer"
 	"github.com/pingcap/pd/server/schedule"
 	"github.com/pingcap/pd/server/schedule/checker"
+	"github.com/pingcap/pd/server/schedule/placement"
 	"github.com/pingcap/pd/server/statistics"
 	"github.com/pkg/errors"
 	"go.uber.org/zap"
@@ -84,6 +85,8 @@ type RaftCluster struct {
 	wg           sync.WaitGroup
 	quit         chan struct{}
 	regionSyncer *syncer.RegionSyncer
+
+	ruleManager *placement.RuleManager
 }
 
 // ClusterStatus saves some state information
@@ -1429,6 +1432,18 @@ func (c *RaftCluster) putRegion(region *core.RegionInfo) error {
 	return nil
 }
 
+// GetRuleManager returns the rule manager reference.
+func (c *RaftCluster) GetRuleManager() *placement.RuleManager {
+	c.RLock()
+	defer c.RUnlock()
+	return c.ruleManager
+}
+
+// FitRegion tries to fit the region with placement rules.
+func (c *RaftCluster) FitRegion(region *core.RegionInfo) *placement.RegionFit {
+	return c.GetRuleManager().FitRegion(c, region)
+}
+
 type prepareChecker struct {
 	reactiveRegions map[uint64]int
 	start           time.Time

server/schedule/opt/opts.go

@@ -19,6 +19,7 @@ import (
 	"github.com/pingcap/kvproto/pkg/metapb"
 	"github.com/pingcap/pd/server/core"
 	"github.com/pingcap/pd/server/namespace"
+	"github.com/pingcap/pd/server/schedule/placement"
 	"github.com/pingcap/pd/server/statistics"
 )
 
@@ -84,4 +85,6 @@ type Cluster interface {
 	// TODO: it should be removed. Schedulers don't need to know anything
 	// about peers.
 	AllocPeer(storeID uint64) (*metapb.Peer, error)
+
+	FitRegion(*core.RegionInfo) *placement.RegionFit
 }

server/schedule/placement/fit.go

@@ -0,0 +1,104 @@
+// Copyright 2019 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package placement
+
+import (
+	"github.com/pingcap/kvproto/pkg/metapb"
+	"github.com/pingcap/pd/server/core"
+)
+
+// RegionFit is the result of fitting a region's peers to rule list.
+type RegionFit struct {
+	RuleFits    []*RuleFit
+	OrphanPeers []*metapb.Peer
+}
+
+// IsSatisfied returns if the rules are properly satisfied.
+func (f *RegionFit) IsSatisfied() bool {
+	if len(f.RuleFits) == 0 {
+		return false
+	}
+	for _, r := range f.RuleFits {
+		if !r.IsSatisfied() {
+			return false
+		}
+	}
+	return len(f.OrphanPeers) == 0
+}
+
+// GetRuleFit returns the RuleFit that contains the peer.
+func (f *RegionFit) GetRuleFit(peerID uint64) *RuleFit {
+	for _, rf := range f.RuleFits {
+		for _, p := range rf.Peers {
+			if p.GetId() == peerID {
+				return rf
+			}
+		}
+	}
+	return nil
+}
+
+// CompareRegionFit determines the superiority of 2 fits.
+func CompareRegionFit(a, b *RegionFit) int {
+	for i := range a.RuleFits {
+		if cmp := compareRuleFit(a.RuleFits[i], b.RuleFits[i]); cmp != 0 {
+			return cmp
+		}
+	}
+	switch {
+	case len(a.OrphanPeers) < len(b.OrphanPeers):
+		return 1
+	case len(a.OrphanPeers) > len(b.OrphanPeers):
+		return -1
+	default:
+		return 0
+	}
+}
+
+// RuleFit is the result of fitting status of a Rule.
+type RuleFit struct {
+	Rule              *Rule
+	Peers             []*metapb.Peer
+	LooseMatchedPeers []*metapb.Peer
+	IsolationLevel    int
+}
+
+// IsSatisfied returns if the rule is properly satisfied.
+func (f *RuleFit) IsSatisfied() bool {
+	return len(f.Peers) == f.Rule.Count && len(f.LooseMatchedPeers) == 0
+}
+
+func compareRuleFit(a, b *RuleFit) int {
+	switch {
+	case len(a.Peers) < len(b.Peers):
+		return -1
+	case len(a.Peers) > len(b.Peers):
+		return 1
+	case len(a.LooseMatchedPeers) > len(b.LooseMatchedPeers):
+		return -1
+	case len(a.LooseMatchedPeers) < len(b.LooseMatchedPeers):
+		return 1
+	case a.IsolationLevel < b.IsolationLevel:
+		return -1
+	case a.IsolationLevel > b.IsolationLevel:
+		return 1
+	default:
+		return 0
+	}
+}
+
+// FitRegion tries to fit peers of a region to the rules.
+func FitRegion(stores core.StoreSetInformer, region *core.RegionInfo, rules []*Rule) *RegionFit {
+	return nil
+}