diff --git a/go/cmd/l2vtgate/main.go b/go/cmd/l2vtgate/main.go
index 2404c1256b8..dd082656c8e 100644
--- a/go/cmd/l2vtgate/main.go
+++ b/go/cmd/l2vtgate/main.go
@@ -28,9 +28,9 @@ import (
 	"github.com/youtube/vitess/go/exit"
 	"github.com/youtube/vitess/go/vt/discovery"
 	"github.com/youtube/vitess/go/vt/servenv"
+	"github.com/youtube/vitess/go/vt/srvtopo"
 	"github.com/youtube/vitess/go/vt/topo"
 	"github.com/youtube/vitess/go/vt/topo/topoproto"
-	"github.com/youtube/vitess/go/vt/vtgate"
 	"github.com/youtube/vitess/go/vt/vtgate/l2vtgate"
 
 	topodatapb "github.com/youtube/vitess/go/vt/proto/topodata"
@@ -44,7 +44,7 @@ var (
 	tabletTypesToWait     = flag.String("tablet_types_to_wait", "", "wait till connected for specified tablet types during Gateway initialization")
 )
 
-var resilientSrvTopoServer *vtgate.ResilientSrvTopoServer
+var resilientServer *srvtopo.ResilientServer
 var healthCheck discovery.HealthCheck
 
 func init() {
@@ -66,7 +66,7 @@ func main() {
 	ts := topo.Open()
 	defer ts.Close()
 
-	resilientSrvTopoServer = vtgate.NewResilientSrvTopoServer(ts, "ResilientSrvTopoServer")
+	resilientServer = srvtopo.NewResilientServer(ts, "ResilientSrvTopoServer")
 
 	healthCheck = discovery.NewHealthCheck(*healthCheckRetryDelay, *healthCheckTimeout)
 	healthCheck.RegisterStats()
@@ -82,7 +82,7 @@ func main() {
 			tabletTypes = append(tabletTypes, tt)
 		}
 	}
-	l2vtg := l2vtgate.Init(healthCheck, ts, resilientSrvTopoServer, "VttabletCall", *cell, *retryCount, tabletTypes)
+	l2vtg := l2vtgate.Init(healthCheck, ts, resilientServer, "VttabletCall", *cell, *retryCount, tabletTypes)
 
 	servenv.OnRun(func() {
 		addStatusParts(l2vtg)
diff --git a/go/cmd/l2vtgate/status.go b/go/cmd/l2vtgate/status.go
index cc1325f3151..194e77a42ad 100644
--- a/go/cmd/l2vtgate/status.go
+++ b/go/cmd/l2vtgate/status.go
@@ -19,8 +19,8 @@ package main
 import (
 	"github.com/youtube/vitess/go/vt/discovery"
 	"github.com/youtube/vitess/go/vt/servenv"
+	"github.com/youtube/vitess/go/vt/srvtopo"
 	_ "github.com/youtube/vitess/go/vt/status"
-	"github.com/youtube/vitess/go/vt/vtgate"
 	"github.com/youtube/vitess/go/vt/vtgate/gateway"
 	"github.com/youtube/vitess/go/vt/vtgate/l2vtgate"
 )
@@ -29,8 +29,8 @@ import (
 var onStatusRegistered func()
 
 func addStatusParts(l2vtgate *l2vtgate.L2VTGate) {
-	servenv.AddStatusPart("Topology Cache", vtgate.TopoTemplate, func() interface{} {
-		return resilientSrvTopoServer.CacheStatus()
+	servenv.AddStatusPart("Topology Cache", srvtopo.TopoTemplate, func() interface{} {
+		return resilientServer.CacheStatus()
 	})
 	servenv.AddStatusPart("Gateway Status", gateway.StatusTemplate, func() interface{} {
 		return l2vtgate.GetGatewayCacheStatus()
diff --git a/go/cmd/vtcombo/main.go b/go/cmd/vtcombo/main.go
index e411f773043..43729f70d83 100644
--- a/go/cmd/vtcombo/main.go
+++ b/go/cmd/vtcombo/main.go
@@ -36,6 +36,7 @@ import (
 	"github.com/youtube/vitess/go/vt/discovery"
 	"github.com/youtube/vitess/go/vt/mysqlctl"
 	"github.com/youtube/vitess/go/vt/servenv"
+	"github.com/youtube/vitess/go/vt/srvtopo"
 	"github.com/youtube/vitess/go/vt/topo"
 	"github.com/youtube/vitess/go/vt/topo/memorytopo"
 	"github.com/youtube/vitess/go/vt/vtctld"
@@ -126,7 +127,7 @@ func main() {
 	}
 
 	// vtgate configuration and init
-	resilientSrvTopoServer := vtgate.NewResilientSrvTopoServer(ts, "ResilientSrvTopoServer")
+	resilientServer := srvtopo.NewResilientServer(ts, "ResilientSrvTopoServer")
 	healthCheck := discovery.NewHealthCheck(1*time.Millisecond /*retryDelay*/, 1*time.Hour /*healthCheckTimeout*/)
 	tabletTypesToWait := []topodatapb.TabletType{
 		topodatapb.TabletType_MASTER,
@@ -137,7 +138,7 @@ func main() {
 	vtgate.QueryLogHandler = "/debug/vtgate/querylog"
 	vtgate.QueryLogzHandler = "/debug/vtgate/querylogz"
 	vtgate.QueryzHandler = "/debug/vtgate/queryz"
-	vtgate.Init(context.Background(), healthCheck, ts, resilientSrvTopoServer, tpb.Cells[0], 2 /*retryCount*/, tabletTypesToWait)
+	vtgate.Init(context.Background(), healthCheck, ts, resilientServer, tpb.Cells[0], 2 /*retryCount*/, tabletTypesToWait)
 
 	// vtctld configuration and init
 	vtctld.InitVtctld(ts)
diff --git a/go/cmd/vtgate/status.go b/go/cmd/vtgate/status.go
index 8c4e52f3b6c..bc7b6ce7fdc 100644
--- a/go/cmd/vtgate/status.go
+++ b/go/cmd/vtgate/status.go
@@ -19,6 +19,7 @@ package main
 import (
 	"github.com/youtube/vitess/go/vt/discovery"
 	"github.com/youtube/vitess/go/vt/servenv"
+	"github.com/youtube/vitess/go/vt/srvtopo"
 	_ "github.com/youtube/vitess/go/vt/status"
 	"github.com/youtube/vitess/go/vt/vtgate"
 	"github.com/youtube/vitess/go/vt/vtgate/gateway"
@@ -34,8 +35,8 @@ func addStatusParts(vtg *vtgate.VTGate) {
 	servenv.AddStatusPart("VSchema", vtgate.VSchemaTemplate, func() interface{} {
 		return vtg.VSchemaStats()
 	})
-	servenv.AddStatusPart("Topology Cache", vtgate.TopoTemplate, func() interface{} {
-		return resilientSrvTopoServer.CacheStatus()
+	servenv.AddStatusPart("Topology Cache", srvtopo.TopoTemplate, func() interface{} {
+		return resilientServer.CacheStatus()
 	})
 	servenv.AddStatusPart("Gateway Status", gateway.StatusTemplate, func() interface{} {
 		return vtg.GetGatewayCacheStatus()
diff --git a/go/cmd/vtgate/vtgate.go b/go/cmd/vtgate/vtgate.go
index bcfd3dd0b41..3c2d9c33260 100644
--- a/go/cmd/vtgate/vtgate.go
+++ b/go/cmd/vtgate/vtgate.go
@@ -30,6 +30,7 @@ import (
 	"github.com/youtube/vitess/go/exit"
 	"github.com/youtube/vitess/go/vt/discovery"
 	"github.com/youtube/vitess/go/vt/servenv"
+	"github.com/youtube/vitess/go/vt/srvtopo"
 	"github.com/youtube/vitess/go/vt/topo"
 	"github.com/youtube/vitess/go/vt/topo/topoproto"
 	"github.com/youtube/vitess/go/vt/vtgate"
@@ -45,7 +46,7 @@ var (
 	tabletTypesToWait     = flag.String("tablet_types_to_wait", "", "wait till connected for specified tablet types during Gateway initialization")
 )
 
-var resilientSrvTopoServer *vtgate.ResilientSrvTopoServer
+var resilientServer *srvtopo.ResilientServer
 var healthCheck discovery.HealthCheck
 
 var initFakeZK func()
@@ -72,7 +73,7 @@ func main() {
 	ts := topo.Open()
 	defer ts.Close()
 
-	resilientSrvTopoServer = vtgate.NewResilientSrvTopoServer(ts, "ResilientSrvTopoServer")
+	resilientServer = srvtopo.NewResilientServer(ts, "ResilientSrvTopoServer")
 
 	healthCheck = discovery.NewHealthCheck(*healthCheckRetryDelay, *healthCheckTimeout)
 	healthCheck.RegisterStats()
@@ -89,7 +90,7 @@ func main() {
 		}
 	}
 
-	vtg := vtgate.Init(context.Background(), healthCheck, ts, resilientSrvTopoServer, *cell, *retryCount, tabletTypes)
+	vtg := vtgate.Init(context.Background(), healthCheck, ts, resilientServer, *cell, *retryCount, tabletTypes)
 
 	servenv.OnRun(func() {
 		addStatusParts(vtg)
diff --git a/go/vt/discovery/tablet_stats_cache_wait.go b/go/vt/discovery/tablet_stats_cache_wait.go
index 21951da0e4d..8589a89e3be 100644
--- a/go/vt/discovery/tablet_stats_cache_wait.go
+++ b/go/vt/discovery/tablet_stats_cache_wait.go
@@ -23,7 +23,7 @@ import (
 	"golang.org/x/net/context"
 
 	"github.com/youtube/vitess/go/vt/concurrency"
-	"github.com/youtube/vitess/go/vt/topo"
+	"github.com/youtube/vitess/go/vt/srvtopo"
 
 	topodatapb "github.com/youtube/vitess/go/vt/proto/topodata"
 )
@@ -66,7 +66,7 @@ func (tc *TabletStatsCache) WaitForAnyTablet(ctx context.Context, cell, keyspace
 // WaitForAllServingTablets waits for at least one healthy serving tablet in
 // the given cell for all keyspaces / shards before returning.
 // It will return ctx.Err() if the context is canceled.
-func (tc *TabletStatsCache) WaitForAllServingTablets(ctx context.Context, ts topo.SrvTopoServer, cell string, types []topodatapb.TabletType) error {
+func (tc *TabletStatsCache) WaitForAllServingTablets(ctx context.Context, ts srvtopo.Server, cell string, types []topodatapb.TabletType) error {
 	keyspaceShards, err := findAllKeyspaceShards(ctx, ts, cell)
 	if err != nil {
 		return err
@@ -76,7 +76,7 @@ func (tc *TabletStatsCache) WaitForAllServingTablets(ctx context.Context, ts top
 }
 
 // findAllKeyspaceShards goes through all serving shards in the topology
-func findAllKeyspaceShards(ctx context.Context, ts topo.SrvTopoServer, cell string) (map[keyspaceShard]bool, error) {
+func findAllKeyspaceShards(ctx context.Context, ts srvtopo.Server, cell string) (map[keyspaceShard]bool, error) {
 	ksNames, err := ts.GetSrvKeyspaceNames(ctx, cell)
 	if err != nil {
 		return nil, err
diff --git a/go/vt/discovery/tablet_stats_cache_wait_test.go b/go/vt/discovery/tablet_stats_cache_wait_test.go
index ece0af3a188..2bf6db0b089 100644
--- a/go/vt/discovery/tablet_stats_cache_wait_test.go
+++ b/go/vt/discovery/tablet_stats_cache_wait_test.go
@@ -17,12 +17,14 @@ limitations under the License.
 package discovery
 
 import (
+	"flag"
 	"reflect"
 	"testing"
 	"time"
 
 	"golang.org/x/net/context"
 
+	"github.com/youtube/vitess/go/vt/srvtopo"
 	"github.com/youtube/vitess/go/vt/topo"
 	"github.com/youtube/vitess/go/vt/topo/memorytopo"
 
@@ -33,9 +35,11 @@ import (
 func TestFindAllKeyspaceShards(t *testing.T) {
 	ctx := context.Background()
 	ts := memorytopo.NewServer("cell1", "cell2")
+	flag.Set("srv_topo_cache_ttl", "0s") // No caching values
+	rs := srvtopo.NewResilientServer(ts, "TestFindAllKeyspaceShards")
 
 	// no keyspace / shards
-	ks, err := findAllKeyspaceShards(ctx, ts, "cell1")
+	ks, err := findAllKeyspaceShards(ctx, rs, "cell1")
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
@@ -60,7 +64,7 @@ func TestFindAllKeyspaceShards(t *testing.T) {
 	}
 
 	// get it
-	ks, err = findAllKeyspaceShards(ctx, ts, "cell1")
+	ks, err = findAllKeyspaceShards(ctx, rs, "cell1")
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
@@ -98,7 +102,7 @@ func TestFindAllKeyspaceShards(t *testing.T) {
 	}
 
 	// get it
-	ks, err = findAllKeyspaceShards(ctx, ts, "cell1")
+	ks, err = findAllKeyspaceShards(ctx, rs, "cell1")
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
diff --git a/go/vt/vtgate/resilient_srv_topo_server.go b/go/vt/srvtopo/resilient_server.go
similarity index 82%
rename from go/vt/vtgate/resilient_srv_topo_server.go
rename to go/vt/srvtopo/resilient_server.go
index fbf4daa6574..6dcd81e92ed 100644
--- a/go/vt/vtgate/resilient_srv_topo_server.go
+++ b/go/vt/srvtopo/resilient_server.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package vtgate
+package srvtopo
 
 import (
 	"flag"
@@ -31,11 +31,11 @@ import (
 	"github.com/youtube/vitess/go/vt/topo"
 
 	topodatapb "github.com/youtube/vitess/go/vt/proto/topodata"
+	vschemapb "github.com/youtube/vitess/go/vt/proto/vschema"
 )
 
 var (
 	srvTopoCacheTTL = flag.Duration("srv_topo_cache_ttl", 1*time.Second, "how long to use cached entries for topology")
-	srvTopoTimeout  = flag.Duration("srv_topo_timeout", 2*time.Second, "topo server timeout")
 )
 
 const (
@@ -44,7 +44,7 @@ const (
 	errorCategory  = "error"
 
 	// TopoTemplate is the HTML to use to display the
-	// ResilientSrvTopoServerCacheStatus object
+	// ResilientServerCacheStatus object
 	TopoTemplate = `
 <style>
   table {
@@ -91,11 +91,11 @@ const (
 `
 )
 
-// ResilientSrvTopoServer is an implementation of SrvTopoServer based
+// ResilientServer is an implementation of srvtopo.Server based
 // on a topo.Server that uses a cache for two purposes:
 // - limit the QPS to the underlying topo.Server
 // - return the last known value of the data if there is an error
-type ResilientSrvTopoServer struct {
+type ResilientServer struct {
 	topoServer *topo.Server
 	cacheTTL   time.Duration
 	counts     *stats.Counters
@@ -149,10 +149,10 @@ type srvKeyspaceEntry struct {
 	lastErrorCtx context.Context
 }
 
-// NewResilientSrvTopoServer creates a new ResilientSrvTopoServer
+// NewResilientServer creates a new ResilientServer
 // based on the provided topo.Server.
-func NewResilientSrvTopoServer(base *topo.Server, counterPrefix string) *ResilientSrvTopoServer {
-	return &ResilientSrvTopoServer{
+func NewResilientServer(base *topo.Server, counterPrefix string) *ResilientServer {
+	return &ResilientServer{
 		topoServer: base,
 		cacheTTL:   *srvTopoCacheTTL,
 		counts:     stats.NewCounters(counterPrefix + "Counts"),
@@ -163,7 +163,7 @@ func NewResilientSrvTopoServer(base *topo.Server, counterPrefix string) *Resilie
 }
 
 // GetSrvKeyspaceNames returns all keyspace names for the given cell.
-func (server *ResilientSrvTopoServer) GetSrvKeyspaceNames(ctx context.Context, cell string) ([]string, error) {
+func (server *ResilientServer) GetSrvKeyspaceNames(ctx context.Context, cell string) ([]string, error) {
 	server.counts.Add(queryCategory, 1)
 
 	// find the entry in the cache, add it if not there
@@ -189,18 +189,16 @@ func (server *ResilientSrvTopoServer) GetSrvKeyspaceNames(ctx context.Context, c
 		return entry.value, entry.lastError
 	}
 
-	// not in cache or too old, get the real value
-	newCtx, cancel := context.WithTimeout(context.Background(), *srvTopoTimeout)
-	defer cancel()
-
-	result, err := server.topoServer.GetSrvKeyspaceNames(newCtx, cell)
+	// Not in cache or too old, get the real value. We use the context that issued
+	// the query here.
+	result, err := server.topoServer.GetSrvKeyspaceNames(ctx, cell)
 	if err != nil {
 		if entry.insertionTime.IsZero() {
 			server.counts.Add(errorCategory, 1)
-			log.Errorf("GetSrvKeyspaceNames(%v, %v) failed: %v (no cached value, caching and returning error)", newCtx, cell, err)
+			log.Errorf("GetSrvKeyspaceNames(%v, %v) failed: %v (no cached value, caching and returning error)", ctx, cell, err)
 		} else {
 			server.counts.Add(cachedCategory, 1)
-			log.Warningf("GetSrvKeyspaceNames(%v, %v) failed: %v (returning cached value: %v %v)", newCtx, cell, err, entry.value, entry.lastError)
+			log.Warningf("GetSrvKeyspaceNames(%v, %v) failed: %v (returning cached value: %v %v)", ctx, cell, err, entry.value, entry.lastError)
 			return entry.value, entry.lastError
 		}
 	}
@@ -209,16 +207,11 @@ func (server *ResilientSrvTopoServer) GetSrvKeyspaceNames(ctx context.Context, c
 	entry.insertionTime = time.Now()
 	entry.value = result
 	entry.lastError = err
-	entry.lastErrorCtx = newCtx
+	entry.lastErrorCtx = ctx
 	return result, err
 }
 
-// WatchSrvVSchema is part of the SrvTopoServer API
-func (server *ResilientSrvTopoServer) WatchSrvVSchema(ctx context.Context, cell string) (*topo.WatchSrvVSchemaData, <-chan *topo.WatchSrvVSchemaData, topo.CancelFunc) {
-	return server.topoServer.WatchSrvVSchema(ctx, cell)
-}
-
-func (server *ResilientSrvTopoServer) getSrvKeyspaceEntry(cell, keyspace string) *srvKeyspaceEntry {
+func (server *ResilientServer) getSrvKeyspaceEntry(cell, keyspace string) *srvKeyspaceEntry {
 	// find the entry in the cache, add it if not there
 	key := cell + "." + keyspace
 	server.mutex.RLock()
@@ -243,7 +236,7 @@ func (server *ResilientSrvTopoServer) getSrvKeyspaceEntry(cell, keyspace string)
 }
 
 // GetSrvKeyspace returns SrvKeyspace object for the given cell and keyspace.
-func (server *ResilientSrvTopoServer) GetSrvKeyspace(ctx context.Context, cell, keyspace string) (*topodatapb.SrvKeyspace, error) {
+func (server *ResilientServer) GetSrvKeyspace(ctx context.Context, cell, keyspace string) (*topodatapb.SrvKeyspace, error) {
 	entry := server.getSrvKeyspaceEntry(cell, keyspace)
 
 	// If the watch is already running, return the value
@@ -315,6 +308,48 @@ func (server *ResilientSrvTopoServer) GetSrvKeyspace(ctx context.Context, cell,
 	return entry.value, entry.lastError
 }
 
+var watchSrvVSchemaSleepTime = 5 * time.Second
+
+// WatchSrvVSchema is part of the srvtopo.Server interface.
+func (server *ResilientServer) WatchSrvVSchema(ctx context.Context, cell string, callback func(*vschemapb.SrvVSchema, error)) {
+	wg := sync.WaitGroup{}
+	wg.Add(1)
+
+	go func() {
+		foundFirstValue := false
+
+		for {
+			current, changes, _ := server.topoServer.WatchSrvVSchema(ctx, cell)
+			callback(current.Value, current.Err)
+			if !foundFirstValue {
+				foundFirstValue = true
+				wg.Done()
+			}
+			if current.Err != nil {
+				// Don't log if there is no VSchema to start with.
+				if current.Err != topo.ErrNoNode {
+					log.Warningf("Error watching vschema for cell %s (will wait 5s before retrying): %v", cell, current.Err)
+				}
+			} else {
+				for c := range changes {
+					// Note we forward topo.ErrNoNode as is.
+					callback(nil, c.Err)
+					if c.Err != nil {
+						log.Warningf("Error while watching vschema for cell %s (will wait 5s before retrying): %v", cell, c.Err)
+						break
+					}
+				}
+			}
+
+			// Sleep a bit before trying again.
+			time.Sleep(watchSrvVSchemaSleepTime)
+		}
+	}()
+
+	// Wait for the first value to have been processed.
+	wg.Wait()
+}
+
 // The next few structures and methods are used to get a displayable
 // version of the cache in a status page.
 
@@ -403,15 +438,15 @@ func (skcsl SrvKeyspaceCacheStatusList) Swap(i, j int) {
 	skcsl[i], skcsl[j] = skcsl[j], skcsl[i]
 }
 
-// ResilientSrvTopoServerCacheStatus has the full status of the cache
-type ResilientSrvTopoServerCacheStatus struct {
+// ResilientServerCacheStatus has the full status of the cache
+type ResilientServerCacheStatus struct {
 	SrvKeyspaceNames SrvKeyspaceNamesCacheStatusList
 	SrvKeyspaces     SrvKeyspaceCacheStatusList
 }
 
 // CacheStatus returns a displayable version of the cache
-func (server *ResilientSrvTopoServer) CacheStatus() *ResilientSrvTopoServerCacheStatus {
-	result := &ResilientSrvTopoServerCacheStatus{}
+func (server *ResilientServer) CacheStatus() *ResilientServerCacheStatus {
+	result := &ResilientServerCacheStatus{}
 	server.mutex.Lock()
 
 	for _, entry := range server.srvKeyspaceNamesCache {
diff --git a/go/vt/vtgate/resilient_srv_topo_server_test.go b/go/vt/srvtopo/resilient_server_test.go
similarity index 59%
rename from go/vt/vtgate/resilient_srv_topo_server_test.go
rename to go/vt/srvtopo/resilient_server_test.go
index b149f759950..00e4fab2479 100644
--- a/go/vt/vtgate/resilient_srv_topo_server_test.go
+++ b/go/vt/srvtopo/resilient_server_test.go
@@ -14,11 +14,12 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package vtgate
+package srvtopo
 
 import (
 	"bytes"
 	"html/template"
+	"sync"
 	"testing"
 	"time"
 
@@ -29,15 +30,16 @@ import (
 	"golang.org/x/net/context"
 
 	topodatapb "github.com/youtube/vitess/go/vt/proto/topodata"
+	vschemapb "github.com/youtube/vitess/go/vt/proto/vschema"
 )
 
 // TestGetSrvKeyspace will test we properly return updated SrvKeyspace.
 func TestGetSrvKeyspace(t *testing.T) {
 	ts := memorytopo.NewServer("test_cell")
-	rsts := NewResilientSrvTopoServer(ts, "TestGetSrvKeyspace")
+	rs := NewResilientServer(ts, "TestGetSrvKeyspace")
 
 	// Ask for a not-yet-created keyspace
-	_, err := rsts.GetSrvKeyspace(context.Background(), "test_cell", "test_ks")
+	_, err := rs.GetSrvKeyspace(context.Background(), "test_cell", "test_ks")
 	if err != topo.ErrNoNode {
 		t.Fatalf("GetSrvKeyspace(not created) got unexpected error: %v", err)
 	}
@@ -53,7 +55,7 @@ func TestGetSrvKeyspace(t *testing.T) {
 	var got *topodatapb.SrvKeyspace
 	expiry := time.Now().Add(5 * time.Second)
 	for {
-		got, err = rsts.GetSrvKeyspace(context.Background(), "test_cell", "test_ks")
+		got, err = rs.GetSrvKeyspace(context.Background(), "test_cell", "test_ks")
 		if err != nil {
 			t.Fatalf("GetSrvKeyspace got unexpected error: %v", err)
 		}
@@ -72,7 +74,7 @@ func TestGetSrvKeyspace(t *testing.T) {
 	}
 	expiry = time.Now().Add(5 * time.Second)
 	for {
-		got, err = rsts.GetSrvKeyspace(context.Background(), "test_cell", "test_ks")
+		got, err = rs.GetSrvKeyspace(context.Background(), "test_cell", "test_ks")
 		if err == topo.ErrNoNode {
 			break
 		}
@@ -90,7 +92,7 @@ func TestGetSrvKeyspace(t *testing.T) {
 	ts.UpdateSrvKeyspace(context.Background(), "test_cell", "test_ks", want)
 	expiry = time.Now().Add(5 * time.Second)
 	for {
-		got, err = rsts.GetSrvKeyspace(context.Background(), "test_cell", "test_ks")
+		got, err = rs.GetSrvKeyspace(context.Background(), "test_cell", "test_ks")
 		if err == nil && proto.Equal(want, got) {
 			break
 		}
@@ -107,7 +109,7 @@ func TestGetSrvKeyspace(t *testing.T) {
 		t.Fatalf("error parsing template: %v", err)
 	}
 	wr := &bytes.Buffer{}
-	if err := templ.Execute(wr, rsts.CacheStatus()); err != nil {
+	if err := templ.Execute(wr, rs.CacheStatus()); err != nil {
 		t.Fatalf("error executing template: %v", err)
 	}
 }
@@ -116,15 +118,15 @@ func TestGetSrvKeyspace(t *testing.T) {
 // the topo server upon failure.
 func TestSrvKeyspaceCachedError(t *testing.T) {
 	ts := memorytopo.NewServer("test_cell")
-	rsts := NewResilientSrvTopoServer(ts, "TestSrvKeyspaceCachedErrors")
+	rs := NewResilientServer(ts, "TestSrvKeyspaceCachedErrors")
 
 	// Ask for an unknown keyspace, should get an error.
 	ctx := context.Background()
-	_, err := rsts.GetSrvKeyspace(ctx, "test_cell", "unknown_ks")
+	_, err := rs.GetSrvKeyspace(ctx, "test_cell", "unknown_ks")
 	if err == nil {
 		t.Fatalf("First GetSrvKeyspace didn't return an error")
 	}
-	entry := rsts.getSrvKeyspaceEntry("test_cell", "unknown_ks")
+	entry := rs.getSrvKeyspaceEntry("test_cell", "unknown_ks")
 	if err != entry.lastError {
 		t.Errorf("Error wasn't saved properly")
 	}
@@ -136,7 +138,7 @@ func TestSrvKeyspaceCachedError(t *testing.T) {
 	// save that context.
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
-	_, err2 := rsts.GetSrvKeyspace(ctx, "test_cell", "unknown_ks")
+	_, err2 := rs.GetSrvKeyspace(ctx, "test_cell", "unknown_ks")
 	if err2 == nil {
 		t.Fatalf("Second GetSrvKeyspace didn't return an error")
 	}
@@ -152,19 +154,19 @@ func TestSrvKeyspaceCachedError(t *testing.T) {
 // value if the SrvKeyspace already exists.
 func TestGetSrvKeyspaceCreated(t *testing.T) {
 	ts := memorytopo.NewServer("test_cell")
-	rsts := NewResilientSrvTopoServer(ts, "TestGetSrvKeyspaceCreated")
+	rs := NewResilientServer(ts, "TestGetSrvKeyspaceCreated")
 
-	// Set SrvKeyspace with value
+	// Set SrvKeyspace with value.
 	want := &topodatapb.SrvKeyspace{
 		ShardingColumnName: "id",
 		ShardingColumnType: topodatapb.KeyspaceIdType_UINT64,
 	}
 	ts.UpdateSrvKeyspace(context.Background(), "test_cell", "test_ks", want)
 
-	// wait until we get the right value
+	// Wait until we get the right value.
 	expiry := time.Now().Add(5 * time.Second)
 	for {
-		got, err := rsts.GetSrvKeyspace(context.Background(), "test_cell", "test_ks")
+		got, err := rs.GetSrvKeyspace(context.Background(), "test_cell", "test_ks")
 		switch err {
 		case topo.ErrNoNode:
 			// keep trying
@@ -182,3 +184,87 @@ func TestGetSrvKeyspaceCreated(t *testing.T) {
 		time.Sleep(10 * time.Millisecond)
 	}
 }
+
+func TestWatchSrvVSchema(t *testing.T) {
+	ctx := context.Background()
+	ts := memorytopo.NewServer("test_cell")
+	rs := NewResilientServer(ts, "TestWatchSrvVSchema")
+	watchSrvVSchemaSleepTime = 10 * time.Millisecond
+
+	// mu protects watchValue and watchErr.
+	mu := sync.Mutex{}
+	var watchValue *vschemapb.SrvVSchema
+	var watchErr error
+	rs.WatchSrvVSchema(ctx, "test_cell", func(v *vschemapb.SrvVSchema, e error) {
+		mu.Lock()
+		defer mu.Unlock()
+		watchValue = v
+		watchErr = e
+	})
+	get := func() (*vschemapb.SrvVSchema, error) {
+		mu.Lock()
+		defer mu.Unlock()
+		return watchValue, watchErr
+	}
+
+	// WatchSrvVSchema won't return until it gets the initial value,
+	// which is not there, so we should get watchErr=topo.ErrNoNode.
+	if _, err := get(); err != topo.ErrNoNode {
+		t.Fatalf("WatchSrvVSchema didn't return topo.ErrNoNode at first, but got: %v", err)
+	}
+
+	// Save a value, wait for it.
+	newValue := &vschemapb.SrvVSchema{
+		Keyspaces: map[string]*vschemapb.Keyspace{
+			"ks1": {},
+		},
+	}
+	if err := ts.UpdateSrvVSchema(ctx, "test_cell", newValue); err != nil {
+		t.Fatalf("UpdateSrvVSchema failed: %v", err)
+	}
+	start := time.Now()
+	for {
+		if v, err := get(); err == nil && proto.Equal(newValue, v) {
+			break
+		}
+		if time.Since(start) > 5*time.Second {
+			t.Fatalf("timed out waiting for new SrvVschema")
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+
+	// Update value, wait for it.
+	updatedValue := &vschemapb.SrvVSchema{
+		Keyspaces: map[string]*vschemapb.Keyspace{
+			"ks1": {},
+		},
+	}
+	if err := ts.UpdateSrvVSchema(ctx, "test_cell", updatedValue); err != nil {
+		t.Fatalf("UpdateSrvVSchema failed: %v", err)
+	}
+	start = time.Now()
+	for {
+		if v, err := get(); err == nil && proto.Equal(updatedValue, v) {
+			break
+		}
+		if time.Since(start) > 5*time.Second {
+			t.Fatalf("timed out waiting for updated SrvVschema")
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+
+	// Delete the value, wait for topo.ErrNoNode
+	if err := ts.DeleteSrvVSchema(ctx, "test_cell"); err != nil {
+		t.Fatalf("DeleteSrvVSchema failed: %v", err)
+	}
+	start = time.Now()
+	for {
+		if _, err := get(); err == topo.ErrNoNode {
+			break
+		}
+		if time.Since(start) > 5*time.Second {
+			t.Fatalf("timed out waiting for deleted SrvVschema")
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+}
diff --git a/go/vt/vtgate/topo_utils.go b/go/vt/srvtopo/resolve.go
similarity index 56%
rename from go/vt/vtgate/topo_utils.go
rename to go/vt/srvtopo/resolve.go
index 19f9d83d83c..08ccd40b992 100644
--- a/go/vt/vtgate/topo_utils.go
+++ b/go/vt/srvtopo/resolve.go
@@ -14,14 +14,13 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package vtgate
+package srvtopo
 
 import (
 	"encoding/hex"
 	"sort"
 
 	"github.com/youtube/vitess/go/vt/key"
-	"github.com/youtube/vitess/go/vt/topo"
 	"github.com/youtube/vitess/go/vt/topo/topoproto"
 	"github.com/youtube/vitess/go/vt/vterrors"
 	"golang.org/x/net/context"
@@ -32,14 +31,16 @@ import (
 	vtrpcpb "github.com/youtube/vitess/go/vt/proto/vtrpc"
 )
 
-func mapKeyspaceIdsToShards(ctx context.Context, topoServ topo.SrvTopoServer, cell, keyspace string, tabletType topodatapb.TabletType, keyspaceIds [][]byte) (string, []string, error) {
-	keyspace, _, allShards, err := getKeyspaceShards(ctx, topoServ, cell, keyspace, tabletType)
+// MapKeyspaceIdsToShards maps the given keyspaceIds to a concrete set
+// of shards.
+func MapKeyspaceIdsToShards(ctx context.Context, topoServ Server, cell, keyspace string, tabletType topodatapb.TabletType, keyspaceIds [][]byte) (string, []string, error) {
+	keyspace, _, allShards, err := GetKeyspaceShards(ctx, topoServ, cell, keyspace, tabletType)
 	if err != nil {
 		return "", nil, err
 	}
 	var shards = make(map[string]bool)
 	for _, ksID := range keyspaceIds {
-		shard, err := getShardForKeyspaceID(allShards, ksID)
+		shard, err := GetShardForKeyspaceID(allShards, ksID)
 		if err != nil {
 			return "", nil, err
 		}
@@ -52,8 +53,10 @@ func mapKeyspaceIdsToShards(ctx context.Context, topoServ topo.SrvTopoServer, ce
 	return keyspace, res, nil
 }
 
-func getAnyShard(ctx context.Context, topoServ topo.SrvTopoServer, cell, keyspace string, tabletType topodatapb.TabletType) (ks, shard string, err error) {
-	keyspace, _, allShards, err := getKeyspaceShards(ctx, topoServ, cell, keyspace, tabletType)
+// GetAnyShard returns a shard from the keyspace. In practice, the
+// implementation now returns the first one.
+func GetAnyShard(ctx context.Context, topoServ Server, cell, keyspace string, tabletType topodatapb.TabletType) (ks, shard string, err error) {
+	keyspace, _, allShards, err := GetKeyspaceShards(ctx, topoServ, cell, keyspace, tabletType)
 	if err != nil {
 		return "", "", err
 	}
@@ -63,7 +66,8 @@ func getAnyShard(ctx context.Context, topoServ topo.SrvTopoServer, cell, keyspac
 	return keyspace, allShards[0].Name, nil
 }
 
-func getAllKeyspaces(ctx context.Context, topoServ topo.SrvTopoServer, cell string) ([]string, error) {
+// GetAllKeyspaces returns all the known keyspaces in a shard.
+func GetAllKeyspaces(ctx context.Context, topoServ Server, cell string) ([]string, error) {
 	keyspaces, err := topoServ.GetSrvKeyspaceNames(ctx, cell)
 	if err != nil {
 		return nil, vterrors.Errorf(vtrpcpb.Code_UNKNOWN, "keyspace names fetch error: %v", err)
@@ -73,7 +77,9 @@ func getAllKeyspaces(ctx context.Context, topoServ topo.SrvTopoServer, cell stri
 	return keyspaces, nil
 }
 
-func getKeyspaceShards(ctx context.Context, topoServ topo.SrvTopoServer, cell, keyspace string, tabletType topodatapb.TabletType) (string, *topodatapb.SrvKeyspace, []*topodatapb.ShardReference, error) {
+// GetKeyspaceShards return all the shards in a keyspace. It follows
+// redirection if ServedFrom is set.
+func GetKeyspaceShards(ctx context.Context, topoServ Server, cell, keyspace string, tabletType topodatapb.TabletType) (string, *topodatapb.SrvKeyspace, []*topodatapb.ShardReference, error) {
 	srvKeyspace, err := topoServ.GetSrvKeyspace(ctx, cell, keyspace)
 	if err != nil {
 		return "", nil, nil, vterrors.Errorf(vtrpcpb.Code_UNKNOWN, "keyspace %v fetch error: %v", keyspace, err)
@@ -97,7 +103,8 @@ func getKeyspaceShards(ctx context.Context, topoServ topo.SrvTopoServer, cell, k
 	return keyspace, srvKeyspace, partition.ShardReferences, nil
 }
 
-func getShardForKeyspaceID(allShards []*topodatapb.ShardReference, keyspaceID []byte) (string, error) {
+// GetShardForKeyspaceID finds the right shard for a keyspace id.
+func GetShardForKeyspaceID(allShards []*topodatapb.ShardReference, keyspaceID []byte) (string, error) {
 	if len(allShards) == 0 {
 		return "", vterrors.New(vtrpcpb.Code_INVALID_ARGUMENT, "No shards found for this tabletType")
 	}
@@ -110,14 +117,15 @@ func getShardForKeyspaceID(allShards []*topodatapb.ShardReference, keyspaceID []
 	return "", vterrors.Errorf(vtrpcpb.Code_INVALID_ARGUMENT, "KeyspaceId %v didn't match any shards %+v", hex.EncodeToString(keyspaceID), allShards)
 }
 
-func mapEntityIdsToShards(ctx context.Context, topoServ topo.SrvTopoServer, cell, keyspace string, entityIds []*vtgatepb.ExecuteEntityIdsRequest_EntityId, tabletType topodatapb.TabletType) (string, map[string][]*querypb.Value, error) {
-	keyspace, _, allShards, err := getKeyspaceShards(ctx, topoServ, cell, keyspace, tabletType)
+// MapEntityIdsToShards returns a map of shards to values to use in that shard.
+func MapEntityIdsToShards(ctx context.Context, topoServ Server, cell, keyspace string, entityIds []*vtgatepb.ExecuteEntityIdsRequest_EntityId, tabletType topodatapb.TabletType) (string, map[string][]*querypb.Value, error) {
+	keyspace, _, allShards, err := GetKeyspaceShards(ctx, topoServ, cell, keyspace, tabletType)
 	if err != nil {
 		return "", nil, err
 	}
 	var shards = make(map[string][]*querypb.Value)
 	for _, eid := range entityIds {
-		shard, err := getShardForKeyspaceID(allShards, eid.KeyspaceId)
+		shard, err := GetShardForKeyspaceID(allShards, eid.KeyspaceId)
 		if err != nil {
 			return "", nil, err
 		}
@@ -126,17 +134,17 @@ func mapEntityIdsToShards(ctx context.Context, topoServ topo.SrvTopoServer, cell
 	return keyspace, shards, nil
 }
 
-// Given a collection of key-ranges, returns the set of shards that "intersect"
-// them; that is, a shard is included if and only if its corresponding key-space ids
-// are in one of the key-ranges.
-func mapKeyRangesToShards(ctx context.Context, topoServ topo.SrvTopoServer, cell, keyspace string, tabletType topodatapb.TabletType, krs []*topodatapb.KeyRange) (string, []string, error) {
-	keyspace, _, allShards, err := getKeyspaceShards(ctx, topoServ, cell, keyspace, tabletType)
+// MapKeyRangesToShards returns the set of shards that "intersect"
+// with a collection of key-ranges; that is, a shard is included if
+// and only if its corresponding key-space ids are in one of the key-ranges.
+func MapKeyRangesToShards(ctx context.Context, topoServ Server, cell, keyspace string, tabletType topodatapb.TabletType, krs []*topodatapb.KeyRange) (string, []string, error) {
+	keyspace, _, allShards, err := GetKeyspaceShards(ctx, topoServ, cell, keyspace, tabletType)
 	if err != nil {
 		return "", nil, err
 	}
 	uniqueShards := make(map[string]bool)
 	for _, kr := range krs {
-		resolveKeyRangeToShards(allShards, uniqueShards, kr)
+		ResolveKeyRangeToShards(allShards, uniqueShards, kr)
 	}
 	var res = make([]string, 0, len(uniqueShards))
 	for s := range uniqueShards {
@@ -145,8 +153,8 @@ func mapKeyRangesToShards(ctx context.Context, topoServ topo.SrvTopoServer, cell
 	return keyspace, res, nil
 }
 
-// This maps a list of keyranges to shard names.
-func resolveKeyRangeToShards(allShards []*topodatapb.ShardReference, matches map[string]bool, kr *topodatapb.KeyRange) {
+// ResolveKeyRangeToShards maps a list of keyranges to shard names.
+func ResolveKeyRangeToShards(allShards []*topodatapb.ShardReference, matches map[string]bool, kr *topodatapb.KeyRange) {
 	if !key.KeyRangeIsPartial(kr) {
 		for _, shard := range allShards {
 			matches[shard.Name] = true
@@ -160,10 +168,10 @@ func resolveKeyRangeToShards(allShards []*topodatapb.ShardReference, matches map
 	}
 }
 
-// mapExactShards maps a keyrange to shards only if there's a complete
+// MapExactShards maps a keyrange to shards only if there's a complete
 // match. If there's any partial match the function returns no match.
-func mapExactShards(ctx context.Context, topoServ topo.SrvTopoServer, cell, keyspace string, tabletType topodatapb.TabletType, kr *topodatapb.KeyRange) (newkeyspace string, shards []string, err error) {
-	keyspace, _, allShards, err := getKeyspaceShards(ctx, topoServ, cell, keyspace, tabletType)
+func MapExactShards(ctx context.Context, topoServ Server, cell, keyspace string, tabletType topodatapb.TabletType, kr *topodatapb.KeyRange) (newkeyspace string, shards []string, err error) {
+	keyspace, _, allShards, err := GetKeyspaceShards(ctx, topoServ, cell, keyspace, tabletType)
 	if err != nil {
 		return "", nil, err
 	}
@@ -183,42 +191,3 @@ func mapExactShards(ctx context.Context, topoServ topo.SrvTopoServer, cell, keys
 	}
 	return keyspace, nil, vterrors.Errorf(vtrpcpb.Code_INVALID_ARGUMENT, "keyrange %v does not exactly match shards", key.KeyRangeString(kr))
 }
-
-func boundShardQueriesToScatterBatchRequest(boundQueries []*vtgatepb.BoundShardQuery) (*scatterBatchRequest, error) {
-	requests := &scatterBatchRequest{
-		Length:   len(boundQueries),
-		Requests: make(map[string]*shardBatchRequest),
-	}
-	for i, boundQuery := range boundQueries {
-		for shard := range unique(boundQuery.Shards) {
-			key := boundQuery.Keyspace + ":" + shard
-			request := requests.Requests[key]
-			if request == nil {
-				request = &shardBatchRequest{
-					Keyspace: boundQuery.Keyspace,
-					Shard:    shard,
-				}
-				requests.Requests[key] = request
-			}
-			request.Queries = append(request.Queries, boundQuery.Query)
-			request.ResultIndexes = append(request.ResultIndexes, i)
-		}
-	}
-	return requests, nil
-}
-
-func boundKeyspaceIDQueriesToBoundShardQueries(ctx context.Context, topoServ topo.SrvTopoServer, cell string, tabletType topodatapb.TabletType, idQueries []*vtgatepb.BoundKeyspaceIdQuery) ([]*vtgatepb.BoundShardQuery, error) {
-	shardQueries := make([]*vtgatepb.BoundShardQuery, len(idQueries))
-	for i, idQuery := range idQueries {
-		keyspace, shards, err := mapKeyspaceIdsToShards(ctx, topoServ, cell, idQuery.Keyspace, tabletType, idQuery.KeyspaceIds)
-		if err != nil {
-			return nil, err
-		}
-		shardQueries[i] = &vtgatepb.BoundShardQuery{
-			Query:    idQuery.Query,
-			Keyspace: keyspace,
-			Shards:   shards,
-		}
-	}
-	return shardQueries, nil
-}
diff --git a/go/vt/srvtopo/resolve_test.go b/go/vt/srvtopo/resolve_test.go
new file mode 100644
index 00000000000..475ebf281d4
--- /dev/null
+++ b/go/vt/srvtopo/resolve_test.go
@@ -0,0 +1,206 @@
+/*
+Copyright 2017 Google 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,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package srvtopo
+
+import (
+	"fmt"
+	"reflect"
+	"sort"
+	"testing"
+
+	"golang.org/x/net/context"
+
+	"github.com/youtube/vitess/go/vt/key"
+	"github.com/youtube/vitess/go/vt/logutil"
+	"github.com/youtube/vitess/go/vt/topo"
+	"github.com/youtube/vitess/go/vt/topo/memorytopo"
+	"github.com/youtube/vitess/go/vt/topotools"
+
+	topodatapb "github.com/youtube/vitess/go/vt/proto/topodata"
+)
+
+func initTopo(name string) (*ResilientServer, error) {
+	ctx := context.Background()
+	cell := "cell1"
+	ts := memorytopo.NewServer(cell)
+	rs := NewResilientServer(ts, name)
+
+	// Create sharded keyspace and shards.
+	if err := ts.CreateKeyspace(ctx, "sks", &topodatapb.Keyspace{}); err != nil {
+		return nil, fmt.Errorf("CreateKeyspace(sks) failed: %v", err)
+	}
+	shardKrArray, err := key.ParseShardingSpec("-20-40-60-80-a0-c0-e0-")
+	if err != nil {
+		return nil, fmt.Errorf("key.ParseShardingSpec failed: %v", err)
+	}
+	for _, kr := range shardKrArray {
+		shard := key.KeyRangeString(kr)
+		if err := ts.CreateShard(ctx, "sks", shard); err != nil {
+			return nil, fmt.Errorf("CreateShard(\"%v\") failed: %v", shard, err)
+		}
+		if _, err := ts.UpdateShardFields(ctx, "sks", shard, func(si *topo.ShardInfo) error {
+			si.Shard.Cells = []string{"cell1"}
+			return nil
+		}); err != nil {
+			return nil, fmt.Errorf("UpdateShardFields(\"%v\") failed: %v", shard, err)
+		}
+	}
+
+	// Create unsharded keyspace and shard.
+	if err := ts.CreateKeyspace(ctx, "uks", &topodatapb.Keyspace{}); err != nil {
+		return nil, fmt.Errorf("CreateKeyspace(uks) failed: %v", err)
+	}
+	if err := ts.CreateShard(ctx, "uks", "0"); err != nil {
+		return nil, fmt.Errorf("CreateShard(0) failed: %v", err)
+	}
+	if _, err := ts.UpdateShardFields(ctx, "uks", "0", func(si *topo.ShardInfo) error {
+		si.Shard.Cells = []string{"cell1"}
+		return nil
+	}); err != nil {
+		return nil, fmt.Errorf("UpdateShardFields(0) failed: %v", err)
+	}
+
+	// And rebuild both.
+	for _, keyspace := range []string{"sks", "uks"} {
+		if err := topotools.RebuildKeyspace(ctx, logutil.NewConsoleLogger(), ts, keyspace, []string{cell}); err != nil {
+			return nil, fmt.Errorf("RebuildKeyspace(%v) failed: %v", keyspace, err)
+		}
+	}
+	return rs, nil
+}
+
+func TestMapKeyRangesToShards(t *testing.T) {
+	ctx := context.Background()
+	rs, err := initTopo("TestMapKeyRangesToShards")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var testCases = []struct {
+		keyspace string
+		keyRange string
+		shards   []string
+	}{
+		{keyspace: "sks", keyRange: "20-40", shards: []string{"20-40"}},
+		// check for partial keyrange, spanning one shard
+		{keyspace: "sks", keyRange: "10-18", shards: []string{"-20"}},
+		// check for keyrange intersecting with multiple shards
+		{keyspace: "sks", keyRange: "10-40", shards: []string{"-20", "20-40"}},
+		// check for keyrange intersecting with multiple shards
+		{keyspace: "sks", keyRange: "1c-2a", shards: []string{"-20", "20-40"}},
+		// check for keyrange where kr.End is Max Key ""
+		{keyspace: "sks", keyRange: "80-", shards: []string{"80-a0", "a0-c0", "c0-e0", "e0-"}},
+		// test for sharded, non-partial keyrange spanning the entire space.
+		{keyspace: "sks", keyRange: "", shards: []string{"-20", "20-40", "40-60", "60-80", "80-a0", "a0-c0", "c0-e0", "e0-"}},
+		// test for unsharded, non-partial keyrange spanning the entire space.
+		{keyspace: "uks", keyRange: "", shards: []string{"0"}},
+	}
+
+	for _, testCase := range testCases {
+		var keyRange *topodatapb.KeyRange
+		var err error
+		if testCase.keyRange == "" {
+			keyRange = &topodatapb.KeyRange{}
+		} else {
+			krArray, err := key.ParseShardingSpec(testCase.keyRange)
+			if err != nil {
+				t.Errorf("Got error while parsing sharding spec %v", err)
+			}
+			keyRange = krArray[0]
+		}
+		krs := []*topodatapb.KeyRange{keyRange}
+		_, gotShards, err := MapKeyRangesToShards(ctx, rs, "cell1", testCase.keyspace, topodatapb.TabletType_MASTER, krs)
+		if err != nil {
+			t.Errorf("want nil, got %v", err)
+		}
+		sort.Strings(gotShards)
+		if !reflect.DeepEqual(testCase.shards, gotShards) {
+			t.Errorf("want \n%#v, got \n%#v", testCase.shards, gotShards)
+		}
+	}
+}
+
+func TestMapExactShards(t *testing.T) {
+	ctx := context.Background()
+	rs, err := initTopo("TestMapExactShards")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var testCases = []struct {
+		keyspace string
+		keyRange string
+		shards   []string
+		err      string
+	}{
+		{keyspace: "sks", keyRange: "20-40", shards: []string{"20-40"}},
+		// check for partial keyrange, spanning one shard
+		{keyspace: "sks", keyRange: "10-18", shards: nil, err: "keyrange 10-18 does not exactly match shards"},
+		// check for keyrange intersecting with multiple shards
+		{keyspace: "sks", keyRange: "10-40", shards: nil, err: "keyrange 10-40 does not exactly match shards"},
+		// check for keyrange intersecting with multiple shards
+		{keyspace: "sks", keyRange: "1c-2a", shards: nil, err: "keyrange 1c-2a does not exactly match shards"},
+		// check for keyrange where kr.End is Max Key ""
+		{keyspace: "sks", keyRange: "80-", shards: []string{"80-a0", "a0-c0", "c0-e0", "e0-"}},
+		// test for sharded, non-partial keyrange spanning the entire space.
+		{keyspace: "sks", keyRange: "", shards: []string{"-20", "20-40", "40-60", "60-80", "80-a0", "a0-c0", "c0-e0", "e0-"}},
+	}
+
+	for _, testCase := range testCases {
+		var keyRange *topodatapb.KeyRange
+		var err error
+		if testCase.keyRange == "" {
+			keyRange = &topodatapb.KeyRange{}
+		} else {
+			krArray, err := key.ParseShardingSpec(testCase.keyRange)
+			if err != nil {
+				t.Errorf("Got error while parsing sharding spec %v", err)
+			}
+			keyRange = krArray[0]
+		}
+		_, gotShards, err := MapExactShards(ctx, rs, "cell1", testCase.keyspace, topodatapb.TabletType_MASTER, keyRange)
+		if err != nil && err.Error() != testCase.err {
+			t.Errorf("gotShards: %v, want %s", err, testCase.err)
+		}
+		if !reflect.DeepEqual(testCase.shards, gotShards) {
+			t.Errorf("want \n%#v, got \n%#v", testCase.shards, gotShards)
+		}
+	}
+}
+
+func BenchmarkResolveKeyRangeToShards(b *testing.B) {
+	ctx := context.Background()
+	rs, err := initTopo("BenchmarkResolveKeyRangeToShards")
+	if err != nil {
+		b.Fatal(err)
+	}
+
+	kr := &topodatapb.KeyRange{
+		Start: []byte{0x40, 0, 0, 0, 0, 0, 0, 0},
+		End:   []byte{0x60, 0, 0, 0, 0, 0, 0, 0},
+	}
+	_, _, allShards, err := GetKeyspaceShards(ctx, rs, "", "sks", topodatapb.TabletType_MASTER)
+	if err != nil {
+		b.Fatal(err)
+	}
+	uniqueShards := map[string]bool{}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		ResolveKeyRangeToShards(allShards, uniqueShards, kr)
+	}
+}
diff --git a/go/vt/srvtopo/server.go b/go/vt/srvtopo/server.go
new file mode 100644
index 00000000000..ed3736c0ad2
--- /dev/null
+++ b/go/vt/srvtopo/server.go
@@ -0,0 +1,45 @@
+/*
+Copyright 2017 Google 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,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+Package srvtopo contains a set of helper methods and classes to
+use the topology service in a serving environment.
+*/
+package srvtopo
+
+import (
+	"golang.org/x/net/context"
+
+	topodatapb "github.com/youtube/vitess/go/vt/proto/topodata"
+	vschemapb "github.com/youtube/vitess/go/vt/proto/vschema"
+)
+
+// Server is a subset of the topo.Server API that only contains
+// the serving graph read-only calls used by clients to resolve
+// serving addresses, and to get VSchema.
+type Server interface {
+	// GetSrvKeyspaceNames returns the list of keyspaces served in
+	// the provided cell.
+	GetSrvKeyspaceNames(ctx context.Context, cell string) ([]string, error)
+
+	// GetSrvKeyspace returns the SrvKeyspace for a cell/keyspace.
+	GetSrvKeyspace(ctx context.Context, cell, keyspace string) (*topodatapb.SrvKeyspace, error)
+
+	// WatchSrvVSchema starts watching the SrvVSchema object for
+	// the provided cell.  It will call the callback when
+	// a new value or an error occurs.
+	WatchSrvVSchema(ctx context.Context, cell string, callback func(*vschemapb.SrvVSchema, error))
+}
diff --git a/go/vt/topo/server.go b/go/vt/topo/server.go
index 60fa84f8442..c14b5e335aa 100644
--- a/go/vt/topo/server.go
+++ b/go/vt/topo/server.go
@@ -50,8 +50,6 @@ import (
 
 	log "github.com/golang/glog"
 	"golang.org/x/net/context"
-
-	topodatapb "github.com/youtube/vitess/go/vt/proto/topodata"
 )
 
 const (
@@ -169,16 +167,6 @@ type Server struct {
 	cells map[string]Conn
 }
 
-// SrvTopoServer is a subset of the topo.Server API that only contains
-// the serving graph read-only calls used by clients to resolve
-// serving addresses, and how to get VSchema. It is mostly used by our
-// discovery modules, and by vtgate.
-type SrvTopoServer interface {
-	GetSrvKeyspaceNames(ctx context.Context, cell string) ([]string, error)
-	GetSrvKeyspace(ctx context.Context, cell, keyspace string) (*topodatapb.SrvKeyspace, error)
-	WatchSrvVSchema(ctx context.Context, cell string) (*WatchSrvVSchemaData, <-chan *WatchSrvVSchemaData, CancelFunc)
-}
-
 type cellsToRegionsMap struct {
 	mu sync.Mutex
 	// cellsToRegions contains all cell->region mappings
diff --git a/go/vt/vtexplain/vtexplain_topo.go b/go/vt/vtexplain/vtexplain_topo.go
index fb94a2ec7d2..cd65a81d1f1 100644
--- a/go/vt/vtexplain/vtexplain_topo.go
+++ b/go/vt/vtexplain/vtexplain_topo.go
@@ -23,13 +23,12 @@ import (
 	"golang.org/x/net/context"
 
 	"github.com/youtube/vitess/go/vt/key"
-	"github.com/youtube/vitess/go/vt/topo"
 
 	topodatapb "github.com/youtube/vitess/go/vt/proto/topodata"
 	vschemapb "github.com/youtube/vitess/go/vt/proto/vschema"
 )
 
-// ExplainTopo satisfies the SrvTopoServer interface.
+// ExplainTopo satisfies the srvtopo.Server interface.
 // Modeled after the vtgate test sandboxTopo
 type ExplainTopo struct {
 	// Map of keyspace name to vschema
@@ -54,7 +53,7 @@ func (et *ExplainTopo) getSrvVSchema() *vschemapb.SrvVSchema {
 	}
 }
 
-// GetSrvKeyspaceNames is part of SrvTopoServer.
+// GetSrvKeyspaceNames is part of the srvtopo.Server interface.
 func (et *ExplainTopo) GetSrvKeyspaceNames(ctx context.Context, cell string) ([]string, error) {
 	et.Lock.Lock()
 	defer et.Lock.Unlock()
@@ -66,7 +65,7 @@ func (et *ExplainTopo) GetSrvKeyspaceNames(ctx context.Context, cell string) ([]
 	return keyspaces, nil
 }
 
-// GetSrvKeyspace is part of SrvTopoServer.
+// GetSrvKeyspace is part of the srvtopo.Server interface.
 func (et *ExplainTopo) GetSrvKeyspace(ctx context.Context, cell, keyspace string) (*topodatapb.SrvKeyspace, error) {
 	et.Lock.Lock()
 	defer et.Lock.Unlock()
@@ -143,9 +142,7 @@ func (et *ExplainTopo) GetSrvKeyspace(ctx context.Context, cell, keyspace string
 	return srvKeyspace, nil
 }
 
-// WatchSrvVSchema is part of SrvTopoServer.
-func (et *ExplainTopo) WatchSrvVSchema(ctx context.Context, cell string) (*topo.WatchSrvVSchemaData, <-chan *topo.WatchSrvVSchemaData, topo.CancelFunc) {
-	return &topo.WatchSrvVSchemaData{
-		Value: et.getSrvVSchema(),
-	}, make(chan *topo.WatchSrvVSchemaData), func() {}
+// WatchSrvVSchema is part of the srvtopo.Server interface.
+func (et *ExplainTopo) WatchSrvVSchema(ctx context.Context, cell string, callback func(*vschemapb.SrvVSchema, error)) {
+	callback(et.getSrvVSchema(), nil)
 }
diff --git a/go/vt/vtexplain/vtexplain_vtgate.go b/go/vt/vtexplain/vtexplain_vtgate.go
index fb2f0a308b8..6a83463afb8 100644
--- a/go/vt/vtexplain/vtexplain_vtgate.go
+++ b/go/vt/vtexplain/vtexplain_vtgate.go
@@ -29,7 +29,7 @@ import (
 
 	"github.com/youtube/vitess/go/vt/discovery"
 	"github.com/youtube/vitess/go/vt/key"
-	"github.com/youtube/vitess/go/vt/topo"
+	"github.com/youtube/vitess/go/vt/srvtopo"
 	"github.com/youtube/vitess/go/vt/vtgate"
 	"github.com/youtube/vitess/go/vt/vtgate/engine"
 	"github.com/youtube/vitess/go/vt/vtgate/gateway"
@@ -70,7 +70,7 @@ func initVtgateExecutor(vSchemaStr string, opts *Options) error {
 	return nil
 }
 
-func newFakeResolver(hc discovery.HealthCheck, serv topo.SrvTopoServer, cell string) *vtgate.Resolver {
+func newFakeResolver(hc discovery.HealthCheck, serv srvtopo.Server, cell string) *vtgate.Resolver {
 	gw := gateway.GetCreator()(hc, nil, serv, cell, 3)
 	gw.WaitForTablets(context.Background(), []topodatapb.TabletType{topodatapb.TabletType_REPLICA})
 	tc := vtgate.NewTxConn(gw, vtgatepb.TransactionMode_MULTI)
diff --git a/go/vt/vtgate/executor.go b/go/vt/vtgate/executor.go
index 0e399db1e10..925a830c4ee 100644
--- a/go/vt/vtgate/executor.go
+++ b/go/vt/vtgate/executor.go
@@ -36,6 +36,7 @@ import (
 	"github.com/youtube/vitess/go/stats"
 	"github.com/youtube/vitess/go/vt/sqlannotation"
 	"github.com/youtube/vitess/go/vt/sqlparser"
+	"github.com/youtube/vitess/go/vt/srvtopo"
 	"github.com/youtube/vitess/go/vt/topo"
 	"github.com/youtube/vitess/go/vt/topo/topoproto"
 	"github.com/youtube/vitess/go/vt/vterrors"
@@ -62,7 +63,7 @@ func init() {
 // Executor is the engine that executes queries by utilizing
 // the abilities of the underlying vttablets.
 type Executor struct {
-	serv        topo.SrvTopoServer
+	serv        srvtopo.Server
 	cell        string
 	resolver    *Resolver
 	scatterConn *ScatterConn
@@ -81,7 +82,7 @@ type Executor struct {
 var executorOnce sync.Once
 
 // NewExecutor creates a new Executor.
-func NewExecutor(ctx context.Context, serv topo.SrvTopoServer, cell, statsName string, resolver *Resolver, normalize bool, streamSize int, queryPlanCacheSize int64, legacyAutocommit bool) *Executor {
+func NewExecutor(ctx context.Context, serv srvtopo.Server, cell, statsName string, resolver *Resolver, normalize bool, streamSize int, queryPlanCacheSize int64, legacyAutocommit bool) *Executor {
 	e := &Executor{
 		serv:             serv,
 		cell:             cell,
@@ -111,7 +112,7 @@ func NewExecutor(ctx context.Context, serv topo.SrvTopoServer, cell, statsName s
 // Execute executes a non-streaming query.
 func (e *Executor) Execute(ctx context.Context, method string, session *vtgatepb.Session, sql string, bindVars map[string]*querypb.BindVariable) (result *sqltypes.Result, err error) {
 	logStats := NewLogStats(ctx, method, sql, bindVars)
-	result, err = e.execute(ctx, method, session, sql, bindVars, logStats)
+	result, err = e.execute(ctx, session, sql, bindVars, logStats)
 	logStats.Error = err
 
 	// The mysql plugin runs an implicit rollback whenever a connection closes.
@@ -123,7 +124,7 @@ func (e *Executor) Execute(ctx context.Context, method string, session *vtgatepb
 	return result, err
 }
 
-func (e *Executor) execute(ctx context.Context, method string, session *vtgatepb.Session, sql string, bindVars map[string]*querypb.BindVariable, logStats *LogStats) (*sqltypes.Result, error) {
+func (e *Executor) execute(ctx context.Context, session *vtgatepb.Session, sql string, bindVars map[string]*querypb.BindVariable, logStats *LogStats) (*sqltypes.Result, error) {
 	// Start an implicit transaction if necessary.
 	// TODO(sougou): deprecate legacyMode after all users are migrated out.
 	if !e.legacyAutocommit && !session.Autocommit && !session.InTransaction {
@@ -282,7 +283,7 @@ func (e *Executor) handleDDL(ctx context.Context, session *vtgatepb.Session, sql
 	f := func(keyspace string) (string, []string, error) {
 		var shards []string
 		if target.Shard == "" {
-			ks, _, allShards, err := getKeyspaceShards(ctx, e.serv, e.cell, keyspace, target.TabletType)
+			ks, _, allShards, err := srvtopo.GetKeyspaceShards(ctx, e.serv, e.cell, keyspace, target.TabletType)
 			if err != nil {
 				return "", nil, err
 			}
@@ -483,7 +484,7 @@ func (e *Executor) handleShow(ctx context.Context, session *vtgatepb.Session, sq
 
 	switch show.Type {
 	case sqlparser.KeywordString(sqlparser.DATABASES), sqlparser.KeywordString(sqlparser.VITESS_KEYSPACES):
-		keyspaces, err := getAllKeyspaces(ctx, e.serv, e.cell)
+		keyspaces, err := srvtopo.GetAllKeyspaces(ctx, e.serv, e.cell)
 		if err != nil {
 			return nil, err
 		}
@@ -499,14 +500,14 @@ func (e *Executor) handleShow(ctx context.Context, session *vtgatepb.Session, sq
 			RowsAffected: uint64(len(rows)),
 		}, nil
 	case sqlparser.KeywordString(sqlparser.VITESS_SHARDS):
-		keyspaces, err := getAllKeyspaces(ctx, e.serv, e.cell)
+		keyspaces, err := srvtopo.GetAllKeyspaces(ctx, e.serv, e.cell)
 		if err != nil {
 			return nil, err
 		}
 
 		var rows [][]sqltypes.Value
 		for _, keyspace := range keyspaces {
-			_, _, shards, err := getKeyspaceShards(ctx, e.serv, e.cell, keyspace, target.TabletType)
+			_, _, shards, err := srvtopo.GetKeyspaceShards(ctx, e.serv, e.cell, keyspace, target.TabletType)
 			if err != nil {
 				// There might be a misconfigured keyspace or no shards in the keyspace.
 				// Skip any errors and move on.
@@ -549,7 +550,7 @@ func (e *Executor) handleShow(ctx context.Context, session *vtgatepb.Session, sq
 			RowsAffected: uint64(len(rows)),
 		}, nil
 	case sqlparser.KeywordString(sqlparser.VINDEXES):
-		vschema := e.srvVschema
+		vschema := e.SrvVSchema()
 		if vschema == nil {
 			return nil, vterrors.Errorf(vtrpcpb.Code_INTERNAL, "vschema not loaded")
 		}
@@ -663,7 +664,7 @@ func (e *Executor) handleOther(ctx context.Context, session *vtgatepb.Session, s
 	}
 	if target.Shard == "" {
 		var err error
-		target.Keyspace, target.Shard, err = getAnyShard(ctx, e.serv, e.cell, target.Keyspace, target.TabletType)
+		target.Keyspace, target.Shard, err = srvtopo.GetAnyShard(ctx, e.serv, e.cell, target.Keyspace, target.TabletType)
 		if err != nil {
 			return nil, err
 		}
@@ -767,7 +768,7 @@ func (e *Executor) MessageAck(ctx context.Context, keyspace, name string, ids []
 		nil,
 	)
 
-	newKeyspace, _, allShards, err := getKeyspaceShards(ctx, e.serv, e.cell, table.Keyspace.Name, topodatapb.TabletType_MASTER)
+	newKeyspace, _, allShards, err := srvtopo.GetKeyspaceShards(ctx, e.serv, e.cell, table.Keyspace.Name, topodatapb.TabletType_MASTER)
 	if err != nil {
 		return 0, err
 	}
@@ -790,7 +791,7 @@ func (e *Executor) MessageAck(ctx context.Context, keyspace, name string, ids []
 			if ksid == nil {
 				continue
 			}
-			shard, err := getShardForKeyspaceID(allShards, ksid)
+			shard, err := srvtopo.GetShardForKeyspaceID(allShards, ksid)
 			if err != nil {
 				return 0, err
 			}
@@ -824,110 +825,80 @@ func (e *Executor) IsKeyspaceRangeBasedSharded(keyspace string) bool {
 // This function will wait until the first value has either been processed
 // or triggered an error before returning.
 func (e *Executor) watchSrvVSchema(ctx context.Context, cell string) {
-	wg := sync.WaitGroup{}
-	wg.Add(1)
-
-	go func() {
-		foundFirstValue := false
-
+	e.serv.WatchSrvVSchema(ctx, cell, func(v *vschemapb.SrvVSchema, err error) {
 		// Create a closure to save the vschema. If the value
 		// passed is nil, it means we encountered an error and
 		// we don't know the real value. In this case, we want
 		// to use the previous value if it was set, or an
 		// empty vschema if it wasn't.
-		saveVSchema := func(v *vschemapb.SrvVSchema, errorMessage string) {
-			// keep a copy of the latest SrvVschema for show statements
-			e.srvVschema = v
-
-			// transform the provided SrvVSchema into a VSchema
-			var vschema *vindexes.VSchema
-			if v != nil {
-				var err error
-				vschema, err = vindexes.BuildVSchema(v)
-				if err != nil {
-					log.Warningf("Error creating VSchema for cell %v (will try again next update): %v", cell, err)
-					v = nil
-					errorMessage = fmt.Sprintf("Error creating VSchema for cell %v: %v", cell, err)
-					if vschemaCounters != nil {
-						vschemaCounters.Add("Parsing", 1)
-					}
-				}
-			}
-			if v == nil {
-				// we encountered an error, build an
-				// empty vschema
-				vschema, _ = vindexes.BuildVSchema(&vschemapb.SrvVSchema{})
-			}
-
-			// Build the display version.
-			stats := NewVSchemaStats(vschema, errorMessage)
-
-			// save our value
-			e.mu.Lock()
-			if v != nil {
-				// no errors, we can save our schema
-				e.vschema = vschema
-			} else {
-				// we had an error, use the empty vschema
-				// if we had nothing before.
-				if e.vschema == nil {
-					e.vschema = vschema
-				}
-			}
-			e.vschemaStats = stats
-			e.mu.Unlock()
-			e.plans.Clear()
-
+		switch err {
+		case nil:
+			// Good case, we can try to save that value.
+		case topo.ErrNoNode:
+			// If the SrvVschema disappears, we need to clear our record.
+			// Otherwise, keep what we already had before.
+			v = nil
+		default:
+			// Watch error, increment our counters.
 			if vschemaCounters != nil {
-				vschemaCounters.Add("Reload", 1)
-			}
-
-			// notify the listener
-			if !foundFirstValue {
-				foundFirstValue = true
-				wg.Done()
+				vschemaCounters.Add("WatchError", 1)
 			}
 		}
 
-		for {
-			current, changes, _ := e.serv.WatchSrvVSchema(ctx, cell)
-			if current.Err != nil {
-				// Don't log if there is no VSchema to start with.
-				if current.Err != topo.ErrNoNode {
-					log.Warningf("Error watching vschema for cell %s (will wait 5s before retrying): %v", cell, current.Err)
-				}
-				saveVSchema(nil, fmt.Sprintf("Error watching SvrVSchema: %v", current.Err.Error()))
+		// Transform the provided SrvVSchema into a VSchema.
+		var vschema *vindexes.VSchema
+		if v != nil {
+			vschema, err = vindexes.BuildVSchema(v)
+			if err != nil {
+				log.Warningf("Error creating VSchema for cell %v (will try again next update): %v", cell, err)
+				v = nil
+				err = fmt.Errorf("Error creating VSchema for cell %v: %v", cell, err)
 				if vschemaCounters != nil {
-					vschemaCounters.Add("WatchError", 1)
+					vschemaCounters.Add("Parsing", 1)
 				}
-				time.Sleep(5 * time.Second)
-				continue
-			}
-			saveVSchema(current.Value, "")
-
-			for c := range changes {
-				if c.Err != nil {
-					// If the SrvVschema disappears, we need to clear our record.
-					// Otherwise, keep what we already had before.
-					if c.Err == topo.ErrNoNode {
-						saveVSchema(nil, "SrvVSchema object was removed from topology.")
-					}
-					log.Warningf("Error while watching vschema for cell %s (will wait 5s before retrying): %v", cell, c.Err)
-					if vschemaCounters != nil {
-						vschemaCounters.Add("WatchError", 1)
-					}
-					break
-				}
-				saveVSchema(c.Value, "")
 			}
+		}
+		if v == nil {
+			// We encountered an error, build an empty vschema.
+			vschema, _ = vindexes.BuildVSchema(&vschemapb.SrvVSchema{})
+		}
 
-			// Sleep a bit before trying again.
-			time.Sleep(5 * time.Second)
+		// Build the display version. At this point, three cases:
+		// - v is nil, vschema is empty, and err is set:
+		//     1. when the watch returned an error.
+		//     2. when BuildVSchema failed.
+		// - v is set, vschema is full, and err is nil:
+		//     3. when everything worked.
+		errorMessage := ""
+		if err != nil {
+			errorMessage = err.Error()
 		}
-	}()
+		stats := NewVSchemaStats(vschema, errorMessage)
+
+		// save our value
+		e.mu.Lock()
+		if v != nil {
+			// No errors, we can save our VSchema and SrvVSchema
+			// (for show queries).
+			e.vschema = vschema
+			e.srvVschema = v
+		} else {
+			// We had an error, use the empty vschema if
+			// we had nothing before, or if the vschema
+			// disappeared.
+			if e.vschema == nil || err == topo.ErrNoNode {
+				e.vschema = vschema
+				e.srvVschema = nil
+			}
+		}
+		e.vschemaStats = stats
+		e.mu.Unlock()
+		e.plans.Clear()
 
-	// wait for the first value to have been processed
-	wg.Wait()
+		if vschemaCounters != nil {
+			vschemaCounters.Add("Reload", 1)
+		}
+	})
 }
 
 // VSchema returns the VSchema.
@@ -937,6 +908,13 @@ func (e *Executor) VSchema() *vindexes.VSchema {
 	return e.vschema
 }
 
+// SrvVSchema returns the SrvVSchema.
+func (e *Executor) SrvVSchema() *vschemapb.SrvVSchema {
+	e.mu.Lock()
+	defer e.mu.Unlock()
+	return e.srvVschema
+}
+
 // ParseTarget parses the string representation of a Target
 // of the form keyspace:shard@tablet_type. You can use a / instead of a :.
 // If the keyspace was not specified in the target, but the VSchema has
diff --git a/go/vt/vtgate/gateway/discoverygateway.go b/go/vt/vtgate/gateway/discoverygateway.go
index 34f28b32c92..2f40b4dea73 100644
--- a/go/vt/vtgate/gateway/discoverygateway.go
+++ b/go/vt/vtgate/gateway/discoverygateway.go
@@ -30,6 +30,7 @@ import (
 
 	"github.com/youtube/vitess/go/flagutil"
 	"github.com/youtube/vitess/go/vt/discovery"
+	"github.com/youtube/vitess/go/vt/srvtopo"
 	"github.com/youtube/vitess/go/vt/topo"
 	"github.com/youtube/vitess/go/vt/vterrors"
 	"github.com/youtube/vitess/go/vt/vtgate/buffer"
@@ -65,7 +66,7 @@ type discoveryGateway struct {
 	hc            discovery.HealthCheck
 	tsc           *discovery.TabletStatsCache
 	topoServer    *topo.Server
-	srvTopoServer topo.SrvTopoServer
+	srvTopoServer srvtopo.Server
 	localCell     string
 	retryCount    int
 
@@ -83,7 +84,7 @@ type discoveryGateway struct {
 	buffer *buffer.Buffer
 }
 
-func createDiscoveryGateway(hc discovery.HealthCheck, topoServer *topo.Server, serv topo.SrvTopoServer, cell string, retryCount int) Gateway {
+func createDiscoveryGateway(hc discovery.HealthCheck, topoServer *topo.Server, serv srvtopo.Server, cell string, retryCount int) Gateway {
 	dg := &discoveryGateway{
 		hc:                hc,
 		tsc:               discovery.NewTabletStatsCacheDoNotSetListener(topoServer, cell),
diff --git a/go/vt/vtgate/gateway/gateway.go b/go/vt/vtgate/gateway/gateway.go
index 47085163c01..36e2c61bbd2 100644
--- a/go/vt/vtgate/gateway/gateway.go
+++ b/go/vt/vtgate/gateway/gateway.go
@@ -26,6 +26,7 @@ import (
 	"golang.org/x/net/context"
 
 	"github.com/youtube/vitess/go/vt/discovery"
+	"github.com/youtube/vitess/go/vt/srvtopo"
 	"github.com/youtube/vitess/go/vt/topo"
 	"github.com/youtube/vitess/go/vt/vttablet/queryservice"
 
@@ -55,7 +56,7 @@ type Gateway interface {
 }
 
 // Creator is the factory method which can create the actual gateway object.
-type Creator func(hc discovery.HealthCheck, topoServer *topo.Server, serv topo.SrvTopoServer, cell string, retryCount int) Gateway
+type Creator func(hc discovery.HealthCheck, topoServer *topo.Server, serv srvtopo.Server, cell string, retryCount int) Gateway
 
 var creators = make(map[string]Creator)
 
diff --git a/go/vt/vtgate/gateway/l2vtgategateway.go b/go/vt/vtgate/gateway/l2vtgategateway.go
index fe63ecf2de5..49c22e2c916 100644
--- a/go/vt/vtgate/gateway/l2vtgategateway.go
+++ b/go/vt/vtgate/gateway/l2vtgategateway.go
@@ -31,6 +31,7 @@ import (
 	"github.com/youtube/vitess/go/vt/discovery"
 	"github.com/youtube/vitess/go/vt/grpcclient"
 	"github.com/youtube/vitess/go/vt/key"
+	"github.com/youtube/vitess/go/vt/srvtopo"
 	"github.com/youtube/vitess/go/vt/topo"
 	"github.com/youtube/vitess/go/vt/topo/topoproto"
 	"github.com/youtube/vitess/go/vt/vttablet/queryservice"
@@ -82,7 +83,7 @@ type l2VTGateGateway struct {
 	statusAggregators map[string]*TabletStatusAggregator
 }
 
-func createL2VTGateGateway(hc discovery.HealthCheck, topoServer *topo.Server, serv topo.SrvTopoServer, cell string, retryCount int) Gateway {
+func createL2VTGateGateway(hc discovery.HealthCheck, topoServer *topo.Server, serv srvtopo.Server, cell string, retryCount int) Gateway {
 	lg := &l2VTGateGateway{
 		retryCount:        retryCount,
 		connMap:           make(map[string][]*l2VTGateConn),
diff --git a/go/vt/vtgate/gatewaytest/grpc_discovery_test.go b/go/vt/vtgate/gatewaytest/grpc_discovery_test.go
index 82f7c91f747..ea85a48b9dd 100644
--- a/go/vt/vtgate/gatewaytest/grpc_discovery_test.go
+++ b/go/vt/vtgate/gatewaytest/grpc_discovery_test.go
@@ -28,6 +28,7 @@ import (
 	"google.golang.org/grpc"
 
 	"github.com/youtube/vitess/go/vt/discovery"
+	"github.com/youtube/vitess/go/vt/srvtopo"
 	"github.com/youtube/vitess/go/vt/vtgate/gateway"
 	"github.com/youtube/vitess/go/vt/vtgate/l2vtgate"
 	"github.com/youtube/vitess/go/vt/vttablet/grpcqueryservice"
@@ -66,7 +67,8 @@ func TestGRPCDiscovery(t *testing.T) {
 	// VTGate: create the discovery healthcheck, and the gateway.
 	// Wait for the right tablets to be present.
 	hc := discovery.NewHealthCheck(10*time.Second, 2*time.Minute)
-	dg := gateway.GetCreator()(hc, ts, ts, cell, 2)
+	rs := srvtopo.NewResilientServer(ts, "TestGRPCDiscovery")
+	dg := gateway.GetCreator()(hc, ts, rs, cell, 2)
 	hc.AddTablet(&topodatapb.Tablet{
 		Alias: &topodatapb.TabletAlias{
 			Cell: cell,
@@ -117,7 +119,8 @@ func TestL2VTGateDiscovery(t *testing.T) {
 	// L2VTGate: Create the discovery healthcheck, and the gateway.
 	// Wait for the right tablets to be present.
 	hc := discovery.NewHealthCheck(10*time.Second, 2*time.Minute)
-	l2vtgate := l2vtgate.Init(hc, ts, ts, "", cell, 2, nil)
+	rs := srvtopo.NewResilientServer(ts, "TestL2VTGateDiscovery")
+	l2vtgate := l2vtgate.Init(hc, ts, rs, "", cell, 2, nil)
 	hc.AddTablet(&topodatapb.Tablet{
 		Alias: &topodatapb.TabletAlias{
 			Cell: cell,
diff --git a/go/vt/vtgate/l2vtgate/l2vtgate.go b/go/vt/vtgate/l2vtgate/l2vtgate.go
index 047672c8107..d78e1cd63c9 100644
--- a/go/vt/vtgate/l2vtgate/l2vtgate.go
+++ b/go/vt/vtgate/l2vtgate/l2vtgate.go
@@ -27,6 +27,7 @@ import (
 	"github.com/youtube/vitess/go/stats"
 	"github.com/youtube/vitess/go/vt/discovery"
 	"github.com/youtube/vitess/go/vt/servenv"
+	"github.com/youtube/vitess/go/vt/srvtopo"
 	"github.com/youtube/vitess/go/vt/topo"
 	"github.com/youtube/vitess/go/vt/topo/topoproto"
 	"github.com/youtube/vitess/go/vt/vterrors"
@@ -58,7 +59,7 @@ type RegisterL2VTGate func(queryservice.QueryService)
 var RegisterL2VTGates []RegisterL2VTGate
 
 // Init creates the single L2VTGate with the provided parameters.
-func Init(hc discovery.HealthCheck, topoServer *topo.Server, serv topo.SrvTopoServer, statsName, cell string, retryCount int, tabletTypesToWait []topodatapb.TabletType) *L2VTGate {
+func Init(hc discovery.HealthCheck, topoServer *topo.Server, serv srvtopo.Server, statsName, cell string, retryCount int, tabletTypesToWait []topodatapb.TabletType) *L2VTGate {
 	if l2VTGate != nil {
 		log.Fatalf("L2VTGate already initialized")
 	}
diff --git a/go/vt/vtgate/resolver.go b/go/vt/vtgate/resolver.go
index 9e3d30efd0b..e00f5fd207a 100644
--- a/go/vt/vtgate/resolver.go
+++ b/go/vt/vtgate/resolver.go
@@ -25,7 +25,7 @@ import (
 
 	"github.com/youtube/vitess/go/sqltypes"
 	"github.com/youtube/vitess/go/vt/sqlparser"
-	"github.com/youtube/vitess/go/vt/topo"
+	"github.com/youtube/vitess/go/vt/srvtopo"
 	"github.com/youtube/vitess/go/vt/vterrors"
 	"github.com/youtube/vitess/go/vt/vtgate/gateway"
 	"golang.org/x/net/context"
@@ -49,12 +49,12 @@ var (
 // resharding happened.
 type Resolver struct {
 	scatterConn *ScatterConn
-	toposerv    topo.SrvTopoServer
+	toposerv    srvtopo.Server
 	cell        string
 }
 
 // NewResolver creates a new Resolver.
-func NewResolver(serv topo.SrvTopoServer, cell string, sc *ScatterConn) *Resolver {
+func NewResolver(serv srvtopo.Server, cell string, sc *ScatterConn) *Resolver {
 	return &Resolver{
 		scatterConn: sc,
 		toposerv:    serv,
@@ -76,7 +76,7 @@ func (res *Resolver) ExecuteKeyspaceIds(ctx context.Context, sql string, bindVar
 		return nil, vterrors.New(vtrpcpb.Code_INVALID_ARGUMENT, "DML should not span multiple keyspace_ids")
 	}
 	mapToShards := func(k string) (string, []string, error) {
-		return mapKeyspaceIdsToShards(
+		return srvtopo.MapKeyspaceIdsToShards(
 			ctx,
 			res.toposerv,
 			res.cell,
@@ -91,7 +91,7 @@ func (res *Resolver) ExecuteKeyspaceIds(ctx context.Context, sql string, bindVar
 // It retries query if new keyspace/shards are re-resolved after a retryable error.
 func (res *Resolver) ExecuteKeyRanges(ctx context.Context, sql string, bindVariables map[string]*querypb.BindVariable, keyspace string, keyRanges []*topodatapb.KeyRange, tabletType topodatapb.TabletType, session *vtgatepb.Session, notInTransaction bool, options *querypb.ExecuteOptions) (*sqltypes.Result, error) {
 	mapToShards := func(k string) (string, []string, error) {
-		return mapKeyRangesToShards(
+		return srvtopo.MapKeyRangesToShards(
 			ctx,
 			res.toposerv,
 			res.cell,
@@ -176,7 +176,7 @@ func (res *Resolver) ExecuteEntityIds(
 	notInTransaction bool,
 	options *querypb.ExecuteOptions,
 ) (*sqltypes.Result, error) {
-	newKeyspace, shardIDMap, err := mapEntityIdsToShards(
+	newKeyspace, shardIDMap, err := srvtopo.MapEntityIdsToShards(
 		ctx,
 		res.toposerv,
 		res.cell,
@@ -201,7 +201,7 @@ func (res *Resolver) ExecuteEntityIds(
 			options)
 		if isRetryableError(err) {
 			resharding := false
-			newKeyspace, newShardIDMap, err := mapEntityIdsToShards(
+			newKeyspace, newShardIDMap, err := srvtopo.MapEntityIdsToShards(
 				ctx,
 				res.toposerv,
 				res.cell,
@@ -236,6 +236,24 @@ func (res *Resolver) ExecuteEntityIds(
 	}
 }
 
+// boundKeyspaceIDQueriesToBoundShardQueries is a helper used by
+// ExecuteBatchKeyspaceIds.
+func boundKeyspaceIDQueriesToBoundShardQueries(ctx context.Context, topoServ srvtopo.Server, cell string, tabletType topodatapb.TabletType, idQueries []*vtgatepb.BoundKeyspaceIdQuery) ([]*vtgatepb.BoundShardQuery, error) {
+	shardQueries := make([]*vtgatepb.BoundShardQuery, len(idQueries))
+	for i, idQuery := range idQueries {
+		keyspace, shards, err := srvtopo.MapKeyspaceIdsToShards(ctx, topoServ, cell, idQuery.Keyspace, tabletType, idQuery.KeyspaceIds)
+		if err != nil {
+			return nil, err
+		}
+		shardQueries[i] = &vtgatepb.BoundShardQuery{
+			Query:    idQuery.Query,
+			Keyspace: keyspace,
+			Shards:   shards,
+		}
+	}
+	return shardQueries, nil
+}
+
 // ExecuteBatchKeyspaceIds executes a group of queries based on KeyspaceIds.
 // It retries query if new keyspace/shards are re-resolved after a retryable error.
 func (res *Resolver) ExecuteBatchKeyspaceIds(ctx context.Context, queries []*vtgatepb.BoundKeyspaceIdQuery, tabletType topodatapb.TabletType, asTransaction bool, session *vtgatepb.Session, options *querypb.ExecuteOptions) ([]sqltypes.Result, error) {
@@ -301,7 +319,7 @@ func (res *Resolver) ExecuteBatch(
 // The api supports supplying multiple KeyspaceIds to make it future proof.
 func (res *Resolver) StreamExecuteKeyspaceIds(ctx context.Context, sql string, bindVariables map[string]*querypb.BindVariable, keyspace string, keyspaceIds [][]byte, tabletType topodatapb.TabletType, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) error {
 	mapToShards := func(k string) (string, []string, error) {
-		return mapKeyspaceIdsToShards(
+		return srvtopo.MapKeyspaceIdsToShards(
 			ctx,
 			res.toposerv,
 			res.cell,
@@ -320,7 +338,7 @@ func (res *Resolver) StreamExecuteKeyspaceIds(ctx context.Context, sql string, b
 // The api supports supplying multiple keyranges to make it future proof.
 func (res *Resolver) StreamExecuteKeyRanges(ctx context.Context, sql string, bindVariables map[string]*querypb.BindVariable, keyspace string, keyRanges []*topodatapb.KeyRange, tabletType topodatapb.TabletType, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) error {
 	mapToShards := func(k string) (string, []string, error) {
-		return mapKeyRangesToShards(
+		return srvtopo.MapKeyRangesToShards(
 			ctx,
 			res.toposerv,
 			res.cell,
@@ -367,11 +385,13 @@ func (res *Resolver) MessageStream(ctx context.Context, keyspace string, shard s
 	var err error
 	if shard != "" {
 		// If we pass in a shard, resolve the keyspace following redirects.
-		keyspace, _, _, err = getKeyspaceShards(ctx, res.toposerv, res.cell, keyspace, topodatapb.TabletType_MASTER)
+		keyspace, _, _, err = srvtopo.GetKeyspaceShards(ctx, res.toposerv, res.cell, keyspace, topodatapb.TabletType_MASTER)
 		shards = []string{shard}
 	} else {
-		// If we pass in a KeyRange, resolve it to one shard only for now.
-		keyspace, shards, err = mapExactShards(ctx, res.toposerv, res.cell, keyspace, topodatapb.TabletType_MASTER, keyRange)
+		// If we pass in a KeyRange, resolve it to the proper shards.
+		// Note we support multiple shards here, we will just aggregate
+		// the message streams.
+		keyspace, shards, err = srvtopo.MapExactShards(ctx, res.toposerv, res.cell, keyspace, topodatapb.TabletType_MASTER, keyRange)
 	}
 	if err != nil {
 		return err
@@ -381,14 +401,14 @@ func (res *Resolver) MessageStream(ctx context.Context, keyspace string, shard s
 
 // MessageAckKeyspaceIds routes message acks based on the associated keyspace ids.
 func (res *Resolver) MessageAckKeyspaceIds(ctx context.Context, keyspace, name string, idKeyspaceIDs []*vtgatepb.IdKeyspaceId) (int64, error) {
-	newKeyspace, _, allShards, err := getKeyspaceShards(ctx, res.toposerv, res.cell, keyspace, topodatapb.TabletType_MASTER)
+	newKeyspace, _, allShards, err := srvtopo.GetKeyspaceShards(ctx, res.toposerv, res.cell, keyspace, topodatapb.TabletType_MASTER)
 	if err != nil {
 		return 0, err
 	}
 
 	shardIDs := make(map[string][]*querypb.Value)
 	for _, idKeyspaceID := range idKeyspaceIDs {
-		shard, err := getShardForKeyspaceID(allShards, idKeyspaceID.KeyspaceId)
+		shard, err := srvtopo.GetShardForKeyspaceID(allShards, idKeyspaceID.KeyspaceId)
 		if err != nil {
 			return 0, err
 		}
@@ -403,7 +423,7 @@ func (res *Resolver) UpdateStream(ctx context.Context, keyspace string, shard st
 	if shard != "" {
 		// If we pass in a shard, resolve the keyspace following redirects.
 		var err error
-		keyspace, _, _, err = getKeyspaceShards(ctx, res.toposerv, res.cell, keyspace, tabletType)
+		keyspace, _, _, err = srvtopo.GetKeyspaceShards(ctx, res.toposerv, res.cell, keyspace, tabletType)
 		if err != nil {
 			return err
 		}
@@ -411,7 +431,7 @@ func (res *Resolver) UpdateStream(ctx context.Context, keyspace string, shard st
 		// If we pass in a KeyRange, resolve it to one shard only for now.
 		var shards []string
 		var err error
-		keyspace, shards, err = mapExactShards(
+		keyspace, shards, err = srvtopo.MapExactShards(
 			ctx,
 			res.toposerv,
 			res.cell,
diff --git a/go/vt/vtgate/resolver_test.go b/go/vt/vtgate/resolver_test.go
index 2dd51684a66..b69760f369d 100644
--- a/go/vt/vtgate/resolver_test.go
+++ b/go/vt/vtgate/resolver_test.go
@@ -19,6 +19,7 @@ limitations under the License.
 package vtgate
 
 import (
+	"encoding/json"
 	"fmt"
 	"reflect"
 	"sort"
@@ -27,7 +28,7 @@ import (
 
 	"github.com/youtube/vitess/go/sqltypes"
 	"github.com/youtube/vitess/go/vt/discovery"
-	"github.com/youtube/vitess/go/vt/topo"
+	"github.com/youtube/vitess/go/vt/srvtopo"
 	"golang.org/x/net/context"
 
 	querypb "github.com/youtube/vitess/go/vt/proto/query"
@@ -662,7 +663,78 @@ func TestResolverExecBatchAsTransaction(t *testing.T) {
 	}
 }
 
-func newTestResolver(hc discovery.HealthCheck, serv topo.SrvTopoServer, cell string) *Resolver {
+func newTestResolver(hc discovery.HealthCheck, serv srvtopo.Server, cell string) *Resolver {
 	sc := newTestScatterConn(hc, serv, cell)
 	return NewResolver(serv, cell, sc)
 }
+
+func TestBoundKeyspaceIdQueriesToBoundShardQueries(t *testing.T) {
+	ts := new(sandboxTopo)
+	kid10 := []byte{0x10}
+	kid25 := []byte{0x25}
+	var testCases = []struct {
+		idQueries    []*vtgatepb.BoundKeyspaceIdQuery
+		shardQueries []*vtgatepb.BoundShardQuery
+	}{
+		{
+			idQueries: []*vtgatepb.BoundKeyspaceIdQuery{
+				{
+					Query: &querypb.BoundQuery{
+						Sql: "q1",
+						BindVariables: map[string]*querypb.BindVariable{
+							"q1var": sqltypes.Int64BindVariable(1),
+						},
+					},
+					Keyspace:    KsTestSharded,
+					KeyspaceIds: [][]byte{kid10, kid25},
+				}, {
+					Query: &querypb.BoundQuery{
+						Sql: "q2",
+						BindVariables: map[string]*querypb.BindVariable{
+							"q2var": sqltypes.Int64BindVariable(2),
+						},
+					},
+					Keyspace:    KsTestSharded,
+					KeyspaceIds: [][]byte{kid25, kid25},
+				},
+			},
+			shardQueries: []*vtgatepb.BoundShardQuery{
+				{
+					Query: &querypb.BoundQuery{
+						Sql: "q1",
+						BindVariables: map[string]*querypb.BindVariable{
+							"q1var": sqltypes.Int64BindVariable(1),
+						},
+					},
+					Keyspace: KsTestSharded,
+					Shards:   []string{"-20", "20-40"},
+				}, {
+					Query: &querypb.BoundQuery{
+						Sql: "q2",
+						BindVariables: map[string]*querypb.BindVariable{
+							"q2var": sqltypes.Int64BindVariable(2),
+						},
+					},
+					Keyspace: KsTestSharded,
+					Shards:   []string{"20-40"},
+				},
+			},
+		},
+	}
+
+	for _, testCase := range testCases {
+		shardQueries, err := boundKeyspaceIDQueriesToBoundShardQueries(context.Background(), ts, "", topodatapb.TabletType_MASTER, testCase.idQueries)
+		if err != nil {
+			t.Error(err)
+		}
+		// Sort shards, because they're random otherwise.
+		for _, shardQuery := range shardQueries {
+			sort.Strings(shardQuery.Shards)
+		}
+		got, _ := json.Marshal(shardQueries)
+		want, _ := json.Marshal(testCase.shardQueries)
+		if string(got) != string(want) {
+			t.Errorf("idQueries: %#v\nResponse:   %s\nExpecting: %s", testCase.idQueries, string(got), string(want))
+		}
+	}
+}
diff --git a/go/vt/vtgate/sandbox_test.go b/go/vt/vtgate/sandbox_test.go
index 83c17cbcc69..0e57e4af2ca 100644
--- a/go/vt/vtgate/sandbox_test.go
+++ b/go/vt/vtgate/sandbox_test.go
@@ -24,7 +24,6 @@ import (
 
 	"github.com/youtube/vitess/go/vt/grpcclient"
 	"github.com/youtube/vitess/go/vt/key"
-	"github.com/youtube/vitess/go/vt/topo"
 	"github.com/youtube/vitess/go/vt/vterrors"
 	"github.com/youtube/vitess/go/vt/vttablet/queryservice"
 	"github.com/youtube/vitess/go/vt/vttablet/sandboxconn"
@@ -214,11 +213,11 @@ func createUnshardedKeyspace() (*topodatapb.SrvKeyspace, error) {
 	return unshardedSrvKeyspace, nil
 }
 
-// sandboxTopo satisfies the SrvTopoServer interface
+// sandboxTopo satisfies the srvtopo.Server interface
 type sandboxTopo struct {
 }
 
-// GetSrvKeyspaceNames is part of SrvTopoServer.
+// GetSrvKeyspaceNames is part of the srvtopo.Server interface.
 func (sct *sandboxTopo) GetSrvKeyspaceNames(ctx context.Context, cell string) ([]string, error) {
 	sandboxMu.Lock()
 	defer sandboxMu.Unlock()
@@ -229,7 +228,7 @@ func (sct *sandboxTopo) GetSrvKeyspaceNames(ctx context.Context, cell string) ([
 	return keyspaces, nil
 }
 
-// GetSrvKeyspace is part of SrvTopoServer.
+// GetSrvKeyspace is part of the srvtopo.Server interface.
 func (sct *sandboxTopo) GetSrvKeyspace(ctx context.Context, cell, keyspace string) (*topodatapb.SrvKeyspace, error) {
 	sand := getSandbox(keyspace)
 	sand.sandmu.Lock()
@@ -266,11 +265,9 @@ func (sct *sandboxTopo) GetSrvKeyspace(ctx context.Context, cell, keyspace strin
 	return createShardedSrvKeyspace(sand.ShardSpec, sand.KeyspaceServedFrom)
 }
 
-// WatchSrvVSchema is part of SrvTopoServer.
-func (sct *sandboxTopo) WatchSrvVSchema(ctx context.Context, cell string) (*topo.WatchSrvVSchemaData, <-chan *topo.WatchSrvVSchemaData, topo.CancelFunc) {
-	return &topo.WatchSrvVSchemaData{
-		Value: getSandboxSrvVSchema(),
-	}, make(chan *topo.WatchSrvVSchemaData), func() {}
+// WatchSrvVSchema is part of the srvtopo.Server interface.
+func (sct *sandboxTopo) WatchSrvVSchema(ctx context.Context, cell string, callback func(*vschemapb.SrvVSchema, error)) {
+	callback(getSandboxSrvVSchema(), nil)
 }
 
 func sandboxDialer(tablet *topodatapb.Tablet, failFast grpcclient.FailFast) (queryservice.QueryService, error) {
diff --git a/go/vt/vtgate/scatter_conn.go b/go/vt/vtgate/scatter_conn.go
index 5a8acaf74b3..451db348961 100644
--- a/go/vt/vtgate/scatter_conn.go
+++ b/go/vt/vtgate/scatter_conn.go
@@ -274,6 +274,29 @@ type shardBatchRequest struct {
 	ResultIndexes   []int
 }
 
+func boundShardQueriesToScatterBatchRequest(boundQueries []*vtgatepb.BoundShardQuery) (*scatterBatchRequest, error) {
+	requests := &scatterBatchRequest{
+		Length:   len(boundQueries),
+		Requests: make(map[string]*shardBatchRequest),
+	}
+	for i, boundQuery := range boundQueries {
+		for shard := range unique(boundQuery.Shards) {
+			key := boundQuery.Keyspace + ":" + shard
+			request := requests.Requests[key]
+			if request == nil {
+				request = &shardBatchRequest{
+					Keyspace: boundQuery.Keyspace,
+					Shard:    shard,
+				}
+				requests.Requests[key] = request
+			}
+			request.Queries = append(request.Queries, boundQuery.Query)
+			request.ResultIndexes = append(request.ResultIndexes, i)
+		}
+	}
+	return requests, nil
+}
+
 // ExecuteBatch executes a batch of non-streaming queries on the specified shards.
 func (stc *ScatterConn) ExecuteBatch(
 	ctx context.Context,
diff --git a/go/vt/vtgate/scatter_conn_test.go b/go/vt/vtgate/scatter_conn_test.go
index 8e50d015338..9a49c9a02b8 100644
--- a/go/vt/vtgate/scatter_conn_test.go
+++ b/go/vt/vtgate/scatter_conn_test.go
@@ -17,6 +17,7 @@ limitations under the License.
 package vtgate
 
 import (
+	"encoding/json"
 	"fmt"
 	"reflect"
 	"strings"
@@ -27,7 +28,7 @@ import (
 	"github.com/golang/protobuf/proto"
 	"github.com/youtube/vitess/go/sqltypes"
 	"github.com/youtube/vitess/go/vt/discovery"
-	"github.com/youtube/vitess/go/vt/topo"
+	"github.com/youtube/vitess/go/vt/srvtopo"
 	"github.com/youtube/vitess/go/vt/vterrors"
 	"github.com/youtube/vitess/go/vt/vtgate/gateway"
 
@@ -563,7 +564,7 @@ func TestShuffleQueryParts(t *testing.T) {
 	injectShuffleQueryPartsRandomGenerator(oldGen)
 }
 
-func newTestScatterConn(hc discovery.HealthCheck, serv topo.SrvTopoServer, cell string) *ScatterConn {
+func newTestScatterConn(hc discovery.HealthCheck, serv srvtopo.Server, cell string) *ScatterConn {
 	// The topo.Server is used to start watching the cells described
 	// in '-cells_to_watch' command line parameter, which is
 	// empty by default. So it's unused in this test, set to nil.
@@ -571,3 +572,137 @@ func newTestScatterConn(hc discovery.HealthCheck, serv topo.SrvTopoServer, cell
 	tc := NewTxConn(gw, vtgatepb.TransactionMode_TWOPC)
 	return NewScatterConn("", tc, gw)
 }
+
+func TestBoundShardQueriesToScatterBatchRequest(t *testing.T) {
+	var testCases = []struct {
+		boundQueries []*vtgatepb.BoundShardQuery
+		requests     *scatterBatchRequest
+	}{
+		{
+			boundQueries: []*vtgatepb.BoundShardQuery{
+				{
+					Query: &querypb.BoundQuery{
+						Sql: "q1",
+						BindVariables: map[string]*querypb.BindVariable{
+							"q1var": sqltypes.Int64BindVariable(1),
+						},
+					},
+					Keyspace: "ks1",
+					Shards:   []string{"0", "1"},
+				}, {
+					Query: &querypb.BoundQuery{
+						Sql: "q2",
+						BindVariables: map[string]*querypb.BindVariable{
+							"q2var": sqltypes.Int64BindVariable(2),
+						},
+					},
+					Keyspace: "ks1",
+					Shards:   []string{"1"},
+				}, {
+					Query: &querypb.BoundQuery{
+						Sql: "q3",
+						BindVariables: map[string]*querypb.BindVariable{
+							"q3var": sqltypes.Int64BindVariable(3),
+						},
+					},
+					Keyspace: "ks2",
+					Shards:   []string{"1"},
+				},
+			},
+			requests: &scatterBatchRequest{
+				Length: 3,
+				Requests: map[string]*shardBatchRequest{
+					"ks1:0": {
+						Queries: []*querypb.BoundQuery{
+							{
+								Sql: "q1",
+								BindVariables: map[string]*querypb.BindVariable{
+									"q1var": sqltypes.Int64BindVariable(1),
+								},
+							},
+						},
+						Keyspace:      "ks1",
+						Shard:         "0",
+						ResultIndexes: []int{0},
+					},
+					"ks1:1": {
+						Queries: []*querypb.BoundQuery{
+							{
+								Sql: "q1",
+								BindVariables: map[string]*querypb.BindVariable{
+									"q1var": sqltypes.Int64BindVariable(1),
+								},
+							}, {
+								Sql: "q2",
+								BindVariables: map[string]*querypb.BindVariable{
+									"q2var": sqltypes.Int64BindVariable(2),
+								},
+							},
+						},
+						Keyspace:      "ks1",
+						Shard:         "1",
+						ResultIndexes: []int{0, 1},
+					},
+					"ks2:1": {
+						Queries: []*querypb.BoundQuery{
+							{
+								Sql: "q3",
+								BindVariables: map[string]*querypb.BindVariable{
+									"q3var": sqltypes.Int64BindVariable(3),
+								},
+							},
+						},
+						Keyspace:      "ks2",
+						Shard:         "1",
+						ResultIndexes: []int{2},
+					},
+				},
+			},
+		},
+		{
+			boundQueries: []*vtgatepb.BoundShardQuery{
+				{
+					Query: &querypb.BoundQuery{
+						Sql: "q1",
+						BindVariables: map[string]*querypb.BindVariable{
+							"q1var": sqltypes.Int64BindVariable(1),
+						},
+					},
+					Keyspace: "ks1",
+					Shards:   []string{"0", "0"},
+				},
+			},
+			requests: &scatterBatchRequest{
+				Length: 1,
+				Requests: map[string]*shardBatchRequest{
+					"ks1:0": {
+						Queries: []*querypb.BoundQuery{
+							{
+								Sql: "q1",
+								BindVariables: map[string]*querypb.BindVariable{
+									"q1var": sqltypes.Int64BindVariable(1),
+								},
+							},
+						},
+						Keyspace:      "ks1",
+						Shard:         "0",
+						ResultIndexes: []int{0},
+					},
+				},
+			},
+		},
+	}
+
+	for _, testCase := range testCases {
+		scatterRequest, err := boundShardQueriesToScatterBatchRequest(testCase.boundQueries)
+		if err != nil {
+			t.Errorf("boundShardQueriesToScatterBatchRequest failed: %v", err)
+			continue
+		}
+		if !reflect.DeepEqual(testCase.requests, scatterRequest) {
+			got, _ := json.Marshal(scatterRequest)
+			want, _ := json.Marshal(testCase.requests)
+			t.Errorf("Bound Query: %#v\nResponse:  %s\nExpecting: %s", testCase.boundQueries, got, want)
+		}
+	}
+}
diff --git a/go/vt/vtgate/topo_utils_test.go b/go/vt/vtgate/topo_utils_test.go
deleted file mode 100644
index 33006c99bc6..00000000000
--- a/go/vt/vtgate/topo_utils_test.go
+++ /dev/null
@@ -1,344 +0,0 @@
-/*
-Copyright 2017 Google 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,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package vtgate
-
-import (
-	"encoding/json"
-	"reflect"
-	"sort"
-	"testing"
-
-	"github.com/youtube/vitess/go/sqltypes"
-	"github.com/youtube/vitess/go/vt/key"
-	"golang.org/x/net/context"
-
-	querypb "github.com/youtube/vitess/go/vt/proto/query"
-	topodatapb "github.com/youtube/vitess/go/vt/proto/topodata"
-	vtgatepb "github.com/youtube/vitess/go/vt/proto/vtgate"
-)
-
-func TestMapKeyRangesToShards(t *testing.T) {
-	ts := new(sandboxTopo)
-	var testCases = []struct {
-		keyspace string
-		keyRange string
-		shards   []string
-	}{
-		{keyspace: KsTestSharded, keyRange: "20-40", shards: []string{"20-40"}},
-		// check for partial keyrange, spanning one shard
-		{keyspace: KsTestSharded, keyRange: "10-18", shards: []string{"-20"}},
-		// check for keyrange intersecting with multiple shards
-		{keyspace: KsTestSharded, keyRange: "10-40", shards: []string{"-20", "20-40"}},
-		// check for keyrange intersecting with multiple shards
-		{keyspace: KsTestSharded, keyRange: "1c-2a", shards: []string{"-20", "20-40"}},
-		// check for keyrange where kr.End is Max Key ""
-		{keyspace: KsTestSharded, keyRange: "80-", shards: []string{"80-a0", "a0-c0", "c0-e0", "e0-"}},
-		// test for sharded, non-partial keyrange spanning the entire space.
-		{keyspace: KsTestSharded, keyRange: "", shards: []string{"-20", "20-40", "40-60", "60-80", "80-a0", "a0-c0", "c0-e0", "e0-"}},
-		// test for unsharded, non-partial keyrange spanning the entire space.
-		{keyspace: KsTestUnsharded, keyRange: "", shards: []string{"0"}},
-	}
-
-	for _, testCase := range testCases {
-		var keyRange *topodatapb.KeyRange
-		var err error
-		if testCase.keyRange == "" {
-			keyRange = &topodatapb.KeyRange{}
-		} else {
-			krArray, err := key.ParseShardingSpec(testCase.keyRange)
-			if err != nil {
-				t.Errorf("Got error while parsing sharding spec %v", err)
-			}
-			keyRange = krArray[0]
-		}
-		krs := []*topodatapb.KeyRange{keyRange}
-		_, gotShards, err := mapKeyRangesToShards(context.Background(), ts, "", testCase.keyspace, topodatapb.TabletType_MASTER, krs)
-		if err != nil {
-			t.Errorf("want nil, got %v", err)
-		}
-		sort.Strings(gotShards)
-		if !reflect.DeepEqual(testCase.shards, gotShards) {
-			t.Errorf("want \n%#v, got \n%#v", testCase.shards, gotShards)
-		}
-	}
-}
-
-func TestMapExactShards(t *testing.T) {
-	ts := new(sandboxTopo)
-	var testCases = []struct {
-		keyspace string
-		keyRange string
-		shards   []string
-		err      string
-	}{
-		{keyspace: KsTestSharded, keyRange: "20-40", shards: []string{"20-40"}},
-		// check for partial keyrange, spanning one shard
-		{keyspace: KsTestSharded, keyRange: "10-18", shards: nil, err: "keyrange 10-18 does not exactly match shards"},
-		// check for keyrange intersecting with multiple shards
-		{keyspace: KsTestSharded, keyRange: "10-40", shards: nil, err: "keyrange 10-40 does not exactly match shards"},
-		// check for keyrange intersecting with multiple shards
-		{keyspace: KsTestSharded, keyRange: "1c-2a", shards: nil, err: "keyrange 1c-2a does not exactly match shards"},
-		// check for keyrange where kr.End is Max Key ""
-		{keyspace: KsTestSharded, keyRange: "80-", shards: []string{"80-a0", "a0-c0", "c0-e0", "e0-"}},
-		// test for sharded, non-partial keyrange spanning the entire space.
-		{keyspace: KsTestSharded, keyRange: "", shards: []string{"-20", "20-40", "40-60", "60-80", "80-a0", "a0-c0", "c0-e0", "e0-"}},
-	}
-
-	for _, testCase := range testCases {
-		var keyRange *topodatapb.KeyRange
-		var err error
-		if testCase.keyRange == "" {
-			keyRange = &topodatapb.KeyRange{}
-		} else {
-			krArray, err := key.ParseShardingSpec(testCase.keyRange)
-			if err != nil {
-				t.Errorf("Got error while parsing sharding spec %v", err)
-			}
-			keyRange = krArray[0]
-		}
-		_, gotShards, err := mapExactShards(context.Background(), ts, "", testCase.keyspace, topodatapb.TabletType_MASTER, keyRange)
-		if err != nil && err.Error() != testCase.err {
-			t.Errorf("gotShards: %v, want %s", err, testCase.err)
-		}
-		if !reflect.DeepEqual(testCase.shards, gotShards) {
-			t.Errorf("want \n%#v, got \n%#v", testCase.shards, gotShards)
-		}
-	}
-}
-
-func TestBoundShardQueriesToScatterBatchRequest(t *testing.T) {
-	var testCases = []struct {
-		boundQueries []*vtgatepb.BoundShardQuery
-		requests     *scatterBatchRequest
-	}{
-		{
-			boundQueries: []*vtgatepb.BoundShardQuery{
-				{
-					Query: &querypb.BoundQuery{
-						Sql: "q1",
-						BindVariables: map[string]*querypb.BindVariable{
-							"q1var": sqltypes.Int64BindVariable(1),
-						},
-					},
-					Keyspace: "ks1",
-					Shards:   []string{"0", "1"},
-				}, {
-					Query: &querypb.BoundQuery{
-						Sql: "q2",
-						BindVariables: map[string]*querypb.BindVariable{
-							"q2var": sqltypes.Int64BindVariable(2),
-						},
-					},
-					Keyspace: "ks1",
-					Shards:   []string{"1"},
-				}, {
-					Query: &querypb.BoundQuery{
-						Sql: "q3",
-						BindVariables: map[string]*querypb.BindVariable{
-							"q3var": sqltypes.Int64BindVariable(3),
-						},
-					},
-					Keyspace: "ks2",
-					Shards:   []string{"1"},
-				},
-			},
-			requests: &scatterBatchRequest{
-				Length: 3,
-				Requests: map[string]*shardBatchRequest{
-					"ks1:0": {
-						Queries: []*querypb.BoundQuery{
-							{
-								Sql: "q1",
-								BindVariables: map[string]*querypb.BindVariable{
-									"q1var": sqltypes.Int64BindVariable(1),
-								},
-							},
-						},
-						Keyspace:      "ks1",
-						Shard:         "0",
-						ResultIndexes: []int{0},
-					},
-					"ks1:1": {
-						Queries: []*querypb.BoundQuery{
-							{
-								Sql: "q1",
-								BindVariables: map[string]*querypb.BindVariable{
-									"q1var": sqltypes.Int64BindVariable(1),
-								},
-							}, {
-								Sql: "q2",
-								BindVariables: map[string]*querypb.BindVariable{
-									"q2var": sqltypes.Int64BindVariable(2),
-								},
-							},
-						},
-						Keyspace:      "ks1",
-						Shard:         "1",
-						ResultIndexes: []int{0, 1},
-					},
-					"ks2:1": {
-						Queries: []*querypb.BoundQuery{
-							{
-								Sql: "q3",
-								BindVariables: map[string]*querypb.BindVariable{
-									"q3var": sqltypes.Int64BindVariable(3),
-								},
-							},
-						},
-						Keyspace:      "ks2",
-						Shard:         "1",
-						ResultIndexes: []int{2},
-					},
-				},
-			},
-		},
-		{
-			boundQueries: []*vtgatepb.BoundShardQuery{
-				{
-					Query: &querypb.BoundQuery{
-						Sql: "q1",
-						BindVariables: map[string]*querypb.BindVariable{
-							"q1var": sqltypes.Int64BindVariable(1),
-						},
-					},
-					Keyspace: "ks1",
-					Shards:   []string{"0", "0"},
-				},
-			},
-			requests: &scatterBatchRequest{
-				Length: 1,
-				Requests: map[string]*shardBatchRequest{
-					"ks1:0": {
-						Queries: []*querypb.BoundQuery{
-							{
-								Sql: "q1",
-								BindVariables: map[string]*querypb.BindVariable{
-									"q1var": sqltypes.Int64BindVariable(1),
-								},
-							},
-						},
-						Keyspace:      "ks1",
-						Shard:         "0",
-						ResultIndexes: []int{0},
-					},
-				},
-			},
-		},
-	}
-
-	for _, testCase := range testCases {
-		scatterRequest, err := boundShardQueriesToScatterBatchRequest(testCase.boundQueries)
-		if err != nil {
-			t.Errorf("boundShardQueriesToScatterBatchRequest failed: %v", err)
-			continue
-		}
-		if !reflect.DeepEqual(testCase.requests, scatterRequest) {
-			got, _ := json.Marshal(scatterRequest)
-			want, _ := json.Marshal(testCase.requests)
-			t.Errorf("Bound Query: %#v\nResponse:  %s\nExpecting: %s", testCase.boundQueries, got, want)
-		}
-	}
-}
-
-func TestBoundKeyspaceIdQueriesToBoundShardQueries(t *testing.T) {
-	ts := new(sandboxTopo)
-	kid10 := []byte{0x10}
-	kid25 := []byte{0x25}
-	var testCases = []struct {
-		idQueries    []*vtgatepb.BoundKeyspaceIdQuery
-		shardQueries []*vtgatepb.BoundShardQuery
-	}{
-		{
-			idQueries: []*vtgatepb.BoundKeyspaceIdQuery{
-				{
-					Query: &querypb.BoundQuery{
-						Sql: "q1",
-						BindVariables: map[string]*querypb.BindVariable{
-							"q1var": sqltypes.Int64BindVariable(1),
-						},
-					},
-					Keyspace:    KsTestSharded,
-					KeyspaceIds: [][]byte{kid10, kid25},
-				}, {
-					Query: &querypb.BoundQuery{
-						Sql: "q2",
-						BindVariables: map[string]*querypb.BindVariable{
-							"q2var": sqltypes.Int64BindVariable(2),
-						},
-					},
-					Keyspace:    KsTestSharded,
-					KeyspaceIds: [][]byte{kid25, kid25},
-				},
-			},
-			shardQueries: []*vtgatepb.BoundShardQuery{
-				{
-					Query: &querypb.BoundQuery{
-						Sql: "q1",
-						BindVariables: map[string]*querypb.BindVariable{
-							"q1var": sqltypes.Int64BindVariable(1),
-						},
-					},
-					Keyspace: KsTestSharded,
-					Shards:   []string{"-20", "20-40"},
-				}, {
-					Query: &querypb.BoundQuery{
-						Sql: "q2",
-						BindVariables: map[string]*querypb.BindVariable{
-							"q2var": sqltypes.Int64BindVariable(2),
-						},
-					},
-					Keyspace: KsTestSharded,
-					Shards:   []string{"20-40"},
-				},
-			},
-		},
-	}
-
-	for _, testCase := range testCases {
-		shardQueries, err := boundKeyspaceIDQueriesToBoundShardQueries(context.Background(), ts, "", topodatapb.TabletType_MASTER, testCase.idQueries)
-		if err != nil {
-			t.Error(err)
-		}
-		// Sort shards, because they're random otherwise.
-		for _, shardQuery := range shardQueries {
-			sort.Strings(shardQuery.Shards)
-		}
-		got, _ := json.Marshal(shardQueries)
-		want, _ := json.Marshal(testCase.shardQueries)
-		if string(got) != string(want) {
-			t.Errorf("idQueries: %#v\nResponse:   %s\nExpecting: %s", testCase.idQueries, string(got), string(want))
-		}
-	}
-}
-
-func BenchmarkResolveKeyRangeToShards(b *testing.B) {
-	ts := new(sandboxTopo)
-	kr := &topodatapb.KeyRange{
-		Start: []byte{0x40, 0, 0, 0, 0, 0, 0, 0},
-		End:   []byte{0x60, 0, 0, 0, 0, 0, 0, 0},
-	}
-	_, _, allShards, err := getKeyspaceShards(context.Background(), ts, "", KsTestSharded, topodatapb.TabletType_MASTER)
-	if err != nil {
-		b.Fatal(err)
-	}
-	uniqueShards := map[string]bool{}
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		resolveKeyRangeToShards(allShards, uniqueShards, kr)
-	}
-}
diff --git a/go/vt/vtgate/vcursor_impl.go b/go/vt/vtgate/vcursor_impl.go
index 72a4cbb2c66..2bd17e9b7bf 100644
--- a/go/vt/vtgate/vcursor_impl.go
+++ b/go/vt/vtgate/vcursor_impl.go
@@ -23,6 +23,7 @@ import (
 
 	"github.com/youtube/vitess/go/sqltypes"
 	"github.com/youtube/vitess/go/vt/sqlparser"
+	"github.com/youtube/vitess/go/vt/srvtopo"
 	"github.com/youtube/vitess/go/vt/vterrors"
 	"github.com/youtube/vitess/go/vt/vtgate/vindexes"
 
@@ -142,7 +143,7 @@ func (vc *vcursorImpl) StreamExecuteMulti(query string, keyspace string, shardVa
 
 // GetKeyspaceShards returns the list of shards for a keyspace, and the mapped keyspace if an alias was used.
 func (vc *vcursorImpl) GetKeyspaceShards(keyspace *vindexes.Keyspace) (string, []*topodatapb.ShardReference, error) {
-	ks, _, allShards, err := getKeyspaceShards(vc.ctx, vc.executor.serv, vc.executor.cell, keyspace.Name, vc.target.TabletType)
+	ks, _, allShards, err := srvtopo.GetKeyspaceShards(vc.ctx, vc.executor.serv, vc.executor.cell, keyspace.Name, vc.target.TabletType)
 	if err != nil {
 		return "", nil, err
 	}
@@ -156,7 +157,7 @@ func (vc *vcursorImpl) GetKeyspaceShards(keyspace *vindexes.Keyspace) (string, [
 }
 
 func (vc *vcursorImpl) GetShardForKeyspaceID(allShards []*topodatapb.ShardReference, keyspaceID []byte) (string, error) {
-	return getShardForKeyspaceID(allShards, keyspaceID)
+	return srvtopo.GetShardForKeyspaceID(allShards, keyspaceID)
 }
 
 func commentedShardQueries(shardQueries map[string]*querypb.BoundQuery, trailingComments string) map[string]*querypb.BoundQuery {
diff --git a/go/vt/vtgate/vtgate.go b/go/vt/vtgate/vtgate.go
index 094204d5772..da60e05f772 100644
--- a/go/vt/vtgate/vtgate.go
+++ b/go/vt/vtgate/vtgate.go
@@ -38,6 +38,7 @@ import (
 	"github.com/youtube/vitess/go/vt/servenv"
 	"github.com/youtube/vitess/go/vt/sqlannotation"
 	"github.com/youtube/vitess/go/vt/sqlparser"
+	"github.com/youtube/vitess/go/vt/srvtopo"
 	"github.com/youtube/vitess/go/vt/topo"
 	"github.com/youtube/vitess/go/vt/topo/topoproto"
 	"github.com/youtube/vitess/go/vt/vterrors"
@@ -143,7 +144,7 @@ var RegisterVTGates []RegisterVTGate
 var vtgateOnce sync.Once
 
 // Init initializes VTGate server.
-func Init(ctx context.Context, hc discovery.HealthCheck, topoServer *topo.Server, serv topo.SrvTopoServer, cell string, retryCount int, tabletTypesToWait []topodatapb.TabletType) *VTGate {
+func Init(ctx context.Context, hc discovery.HealthCheck, topoServer *topo.Server, serv srvtopo.Server, cell string, retryCount int, tabletTypesToWait []topodatapb.TabletType) *VTGate {
 	if rpcVTGate != nil {
 		log.Fatalf("VTGate already initialized")
 	}
@@ -812,7 +813,7 @@ func (vtg *VTGate) SplitQuery(
 	}
 
 	// TODO(erez): Add validation of SplitQuery parameters.
-	keyspace, srvKeyspace, shardRefs, err := getKeyspaceShards(
+	keyspace, srvKeyspace, shardRefs, err := srvtopo.GetKeyspaceShards(
 		ctx, vtg.resolver.toposerv, vtg.resolver.cell, keyspace, topodatapb.TabletType_RDONLY)
 	if err != nil {
 		return nil, err
@@ -833,10 +834,35 @@ func (vtg *VTGate) SplitQuery(
 		for _, shardRef := range shardRefs {
 			shardRefByName[shardRef.Name] = shardRef
 		}
-		querySplitToQueryPartFunc = getQuerySplitToKeyRangePartFunc(keyspace, shardRefByName)
+		querySplitToQueryPartFunc = func(querySplit *querypb.QuerySplit, shard string) (*vtgatepb.SplitQueryResponse_Part, error) {
+			// TODO(erez): Assert that shardRefByName contains an entry for 'shard'.
+			// Keyrange can be nil for the shard (e.g. for single-sharded keyspaces during resharding).
+			// In this case we append an empty keyrange that represents the entire keyspace.
+			keyranges := []*topodatapb.KeyRange{{Start: []byte{}, End: []byte{}}}
+			if shardRefByName[shard].KeyRange != nil {
+				keyranges = []*topodatapb.KeyRange{shardRefByName[shard].KeyRange}
+			}
+			return &vtgatepb.SplitQueryResponse_Part{
+				Query: querySplit.Query,
+				KeyRangePart: &vtgatepb.SplitQueryResponse_KeyRangePart{
+					Keyspace:  keyspace,
+					KeyRanges: keyranges,
+				},
+				Size: querySplit.RowCount,
+			}, nil
+		}
 	} else {
 		// Keyspace is either unsharded or custom-sharded.
-		querySplitToQueryPartFunc = getQuerySplitToShardPartFunc(keyspace)
+		querySplitToQueryPartFunc = func(querySplit *querypb.QuerySplit, shard string) (*vtgatepb.SplitQueryResponse_Part, error) {
+			return &vtgatepb.SplitQueryResponse_Part{
+				Query: querySplit.Query,
+				ShardPart: &vtgatepb.SplitQueryResponse_ShardPart{
+					Keyspace: keyspace,
+					Shards:   []string{shard},
+				},
+				Size: querySplit.RowCount,
+			}, nil
+		}
 	}
 
 	// Collect all shard names into a slice.
@@ -857,53 +883,6 @@ func (vtg *VTGate) SplitQuery(
 		keyspace)
 }
 
-// getQuerySplitToKeyRangePartFunc returns a function to use with scatterConn.SplitQuery
-// that converts the given QuerySplit to a SplitQueryResponse_Part message whose KeyRangePart field
-// is set.
-func getQuerySplitToKeyRangePartFunc(
-	keyspace string,
-	shardReferenceByName map[string]*topodatapb.ShardReference) func(
-	querySplit *querypb.QuerySplit, shard string) (*vtgatepb.SplitQueryResponse_Part, error) {
-
-	return func(
-		querySplit *querypb.QuerySplit, shard string) (*vtgatepb.SplitQueryResponse_Part, error) {
-		// TODO(erez): Assert that shardReferenceByName contains an entry for 'shard'.
-		// Keyrange can be nil for the shard (e.g. for single-sharded keyspaces during resharding).
-		// In this case we append an empty keyrange that represents the entire keyspace.
-		keyranges := []*topodatapb.KeyRange{{Start: []byte{}, End: []byte{}}}
-		if shardReferenceByName[shard].KeyRange != nil {
-			keyranges = []*topodatapb.KeyRange{shardReferenceByName[shard].KeyRange}
-		}
-		return &vtgatepb.SplitQueryResponse_Part{
-			Query: querySplit.Query,
-			KeyRangePart: &vtgatepb.SplitQueryResponse_KeyRangePart{
-				Keyspace:  keyspace,
-				KeyRanges: keyranges,
-			},
-			Size: querySplit.RowCount,
-		}, nil
-	}
-}
-
-// getQuerySplitToShardPartFunc returns a function to use with scatterConn.SplitQuery
-// that converts the given QuerySplit to a SplitQueryResponse_Part message whose ShardPart field
-// is set.
-func getQuerySplitToShardPartFunc(keyspace string) func(
-	querySplit *querypb.QuerySplit, shard string) (*vtgatepb.SplitQueryResponse_Part, error) {
-
-	return func(
-		querySplit *querypb.QuerySplit, shard string) (*vtgatepb.SplitQueryResponse_Part, error) {
-		return &vtgatepb.SplitQueryResponse_Part{
-			Query: querySplit.Query,
-			ShardPart: &vtgatepb.SplitQueryResponse_ShardPart{
-				Keyspace: keyspace,
-				Shards:   []string{shard},
-			},
-			Size: querySplit.RowCount,
-		}, nil
-	}
-}
-
 // GetSrvKeyspace is part of the vtgate service API.
 func (vtg *VTGate) GetSrvKeyspace(ctx context.Context, keyspace string) (*topodatapb.SrvKeyspace, error) {
 	return vtg.resolver.toposerv.GetSrvKeyspace(ctx, vtg.resolver.cell, keyspace)
diff --git a/test/utils.py b/test/utils.py
index b328eba06d2..fa7cecce373 100644
--- a/test/utils.py
+++ b/test/utils.py
@@ -635,6 +635,11 @@ def get_vars(self):
     """Returns the vars for this process."""
     return get_vars(self.port)
 
+  def get_vschema(self):
+    """Returns the used vschema for this process."""
+    return urllib2.urlopen('http://localhost:%d/debug/vschema' %
+                           self.port).read()
+
   @contextlib.contextmanager
   def create_connection(self):
     """Connects to vtgate and allows to create a cursor to execute queries.
diff --git a/test/vtgatev2_test.py b/test/vtgatev2_test.py
index 6507ad76be7..1f167f36670 100755
--- a/test/vtgatev2_test.py
+++ b/test/vtgatev2_test.py
@@ -695,7 +695,7 @@ def test_streaming_fetchone(self):
         cursorclass=vtgate_cursor.StreamVTGateCursor)
     stream_cursor.execute('select * from vt_insert_test', {})
     rows = stream_cursor.fetchone()
-    self.assertTrue(isinstance(rows, tuple), 'Received a valid row')
+    self.assertIsInstance(rows, tuple, 'Received a valid row')
     stream_cursor.close()
     vtgate_conn.close()
 
@@ -906,9 +906,8 @@ def test_vschema_vars(self):
     v = utils.vtgate.get_vars()
     self.assertIn('VtgateVSchemaCounts', v)
     self.assertIn('Reload', v['VtgateVSchemaCounts'])
-    self.assertTrue(v['VtgateVSchemaCounts']['Reload'] > 0)
-    self.assertIn('WatchError', v['VtgateVSchemaCounts'])
-    self.assertTrue(v['VtgateVSchemaCounts']['WatchError'] > 0)
+    self.assertGreater(v['VtgateVSchemaCounts']['Reload'], 0)
+    self.assertNotIn('WatchError', v['VtgateVSchemaCounts'])
     self.assertNotIn('Parsing', v['VtgateVSchemaCounts'])
 
 
@@ -1136,7 +1135,7 @@ def test_error_on_dml(self):
       # instead of poking into it like this.
       logging.info('Shard session: %s', vtgate_conn.session)
       transaction_id = vtgate_conn.session.shard_sessions[0].transaction_id
-      self.assertTrue(transaction_id != 0)
+      self.assertNotEqual(transaction_id, 0)
     except Exception, e:  # pylint: disable=broad-except
       self.fail('Expected DatabaseError as exception, got %s' % str(e))
     finally:
@@ -1543,8 +1542,8 @@ def test_fail_fast_when_no_serving_tablets(self):
     # The true upper limit is 2 seconds (1s * 2 retries as in
     # utils.py). To account for network latencies and other variances,
     # we keep an upper bound of 3 here.
-    self.assertTrue(
-        max(rt_times) < 3,
+    self.assertLess(
+        max(rt_times), 3,
         'at least one request did not fail-fast; round trip times: %s' %
         rt_times)
 
diff --git a/test/vtgatev3_test.py b/test/vtgatev3_test.py
index eb905112927..f0564bc28b0 100755
--- a/test/vtgatev3_test.py
+++ b/test/vtgatev3_test.py
@@ -589,6 +589,14 @@ def test_srv_vschema(self):
     self.assertIn('user', v['keyspaces'])
     self.assertIn('lookup', v['keyspaces'])
 
+    # Wait for vtgate to re-read it.
+    timeout = 10
+    while True:
+      vschema_json = utils.vtgate.get_vschema()
+      if 'lookup' in vschema_json:
+        break
+      timeout = utils.wait_step('vtgate re-read vschema', timeout)
+
   def test_user(self):
     count = 4
     vtgate_conn = get_connection()
@@ -1084,7 +1092,8 @@ def test_multicolvin(self):
         vtgate_conn,
         'insert into vt_multicolvin (cola, colb, colc, kid) '
         'values (:cola, :colb, :colc, :kid)',
-        {'kid': 5, 'cola': 'cola_value', 'colb': 'colb_value', 'colc': 'colc_value'})
+        {'kid': 5, 'cola': 'cola_value', 'colb': 'colb_value',
+         'colc': 'colc_value'})
     self.assertEqual(result, ([], 1L, 0L, []))
     vtgate_conn.commit()
 
@@ -1092,12 +1101,15 @@ def test_multicolvin(self):
     vtgate_conn.begin()
     result = self.execute_on_master(
         vtgate_conn,
-        'update vt_multicolvin set cola = :cola, colb = :colb, colc = :colc where kid = :kid',
-        {'kid': 5, 'cola': 'cola_newvalue', 'colb': 'colb_newvalue', 'colc': 'colc_newvalue'})
+        'update vt_multicolvin set cola = :cola, colb = :colb, colc = :colc'
+        ' where kid = :kid',
+        {'kid': 5, 'cola': 'cola_newvalue', 'colb': 'colb_newvalue',
+         'colc': 'colc_newvalue'})
     self.assertEqual(result, ([], 1L, 0L, []))
     vtgate_conn.commit()
     result = self.execute_on_master(
-        vtgate_conn, 'select cola, colb, colc from vt_multicolvin where kid = 5', {})
+        vtgate_conn,
+        'select cola, colb, colc from vt_multicolvin where kid = 5', {})
     self.assertEqual(
         result,
         ([('cola_newvalue', 'colb_newvalue', 'colc_newvalue')], 1, 0,
@@ -1142,9 +1154,12 @@ def test_multicolvin(self):
     result = self.execute_on_master(
         vtgate_conn,
         'insert into vt_multicolvin (cola, colb, colc, kid) '
-        'values (:cola0, :colb0, :colc0, :kid0), (:cola1, :colb1, :colc1, :kid1)',
-        {'kid0': 6, 'cola0': 'cola0_value', 'colb0': 'colb0_value', 'colc0': 'colc0_value',
-         'kid1': 7, 'cola1': 'cola1_value', 'colb1': 'colb1_value', 'colc1': 'colc1_value'
+        'values (:cola0, :colb0, :colc0, :kid0),'
+        ' (:cola1, :colb1, :colc1, :kid1)',
+        {'kid0': 6, 'cola0': 'cola0_value', 'colb0': 'colb0_value',
+         'colc0': 'colc0_value',
+         'kid1': 7, 'cola1': 'cola1_value', 'colb1': 'colb1_value',
+         'colc1': 'colc1_value'
         })
     self.assertEqual(result, ([], 2L, 0L, []))
     vtgate_conn.commit()
@@ -1746,14 +1761,13 @@ def test_vschema_vars(self):
     """Tests the variables exported by vtgate.
 
     This test needs to run as the last test, as it depends on what happened
-    previously. The WatchError happens when we delete and re-create the
-    SrvVSchema.
+    previously.
     """
     v = utils.vtgate.get_vars()
     self.assertIn('VtgateVSchemaCounts', v)
     self.assertIn('Reload', v['VtgateVSchemaCounts'])
     self.assertGreater(v['VtgateVSchemaCounts']['Reload'], 0)
-    self.assertGreater(v['VtgateVSchemaCounts']['WatchError'], 0)
+    self.assertNotIn('WatchError', v['VtgateVSchemaCounts'], 0)
     self.assertNotIn('Parsing', v['VtgateVSchemaCounts'])
 
 if __name__ == '__main__':