*: write system timezone into mysql.tidb in bootstrap stage.

executor/distsql.go

@@ -126,6 +126,8 @@ func zone(sctx sessionctx.Context) (string, int64) {
 	_, offset := time.Now().In(loc).Zone()
 	var name string
 	name = loc.String()
+	// when we found name is "Local", we have no chice but push down
+	// "System" to tikv side.
 	if name == "Local" {
 		name = "System"
 	}

expression/builtin_time_test.go

@@ -32,6 +32,7 @@ import (
 	"github.com/pingcap/tidb/util/mock"
 	"github.com/pingcap/tidb/util/testleak"
 	"github.com/pingcap/tidb/util/testutil"
+	"github.com/pingcap/tidb/util/timeutil"
 )
 
 func (s *testEvaluatorSuite) TestDate(c *C) {
@@ -774,7 +775,7 @@ func (s *testEvaluatorSuite) TestNowAndUTCTimestamp(c *C) {
 		fc  functionClass
 		now func() time.Time
 	}{
-		{funcs[ast.Now], func() time.Time { return time.Now() }},
+		{funcs[ast.Now], func() time.Time { return time.Now().In(s.ctx.GetSessionVars().Location()) }},
 		{funcs[ast.UTCTimestamp], func() time.Time { return time.Now().UTC() }},
 	} {
 		f, err := x.fc.getFunction(s.ctx, s.datumsToConstants(nil))
@@ -997,7 +998,7 @@ func (s *testEvaluatorSuite) TestSysDate(c *C) {
 	fc := funcs[ast.Sysdate]
 
 	ctx := mock.NewContext()
-	ctx.GetSessionVars().StmtCtx.TimeZone = time.Local
+	ctx.GetSessionVars().StmtCtx.TimeZone = timeutil.Local()
 	timezones := []types.Datum{types.NewDatum(1234), types.NewDatum(0)}
 	for _, timezone := range timezones {
 		// sysdate() result is not affected by "timestamp" session variable.
@@ -1011,7 +1012,7 @@ func (s *testEvaluatorSuite) TestSysDate(c *C) {
 		c.Assert(n.String(), GreaterEqual, last.Format(types.TimeFormat))
 	}
 
-	last := time.Now()
+	last := time.Now().In(s.ctx.GetSessionVars().Location())
 	f, err := fc.getFunction(ctx, s.datumsToConstants(types.MakeDatums(6)))
 	c.Assert(err, IsNil)
 	v, err := evalBuiltinFunc(f, chunk.Row{})
@@ -1156,7 +1157,7 @@ func (s *testEvaluatorSuite) TestCurrentTime(c *C) {
 	defer testleak.AfterTest(c)()
 	tfStr := "15:04:05"
 
-	last := time.Now()
+	last := time.Now().In(s.ctx.GetSessionVars().Location())
 	fc := funcs[ast.CurrentTime]
 	f, err := fc.getFunction(s.ctx, s.datumsToConstants(types.MakeDatums(nil)))
 	c.Assert(err, IsNil)

expression/helper.go

@@ -121,7 +121,7 @@ func GetTimeValue(ctx sessionctx.Context, v interface{}, tp byte, fsp int) (d ty
 }
 
 func getSystemTimestamp(ctx sessionctx.Context) (time.Time, error) {
-	now := time.Now()
+	now := time.Now().In(ctx.GetSessionVars().Location())
 
 	if ctx == nil {
 		return now, nil

expression/helper_test.go

@@ -68,7 +68,7 @@ func (s *testExpressionSuite) TestGetTimeValue(c *C) {
 		Ret  interface{}
 	}{
 		{"2012-12-12 00:00:00", "2012-12-12 00:00:00"},
-		{ast.CurrentTimestamp, time.Unix(1234, 0).Format(types.TimeFormat)},
+		{ast.CurrentTimestamp, time.Unix(1234, 0).In(ctx.GetSessionVars().Location()).Format(types.TimeFormat)},
 		{types.ZeroDatetimeStr, "0000-00-00 00:00:00"},
 		{ast.NewValueExpr("2012-12-12 00:00:00"), "2012-12-12 00:00:00"},
 		{ast.NewValueExpr(int64(0)), "0000-00-00 00:00:00"},

sessionctx/variable/session.go

@@ -30,6 +30,7 @@ import (
 	"github.com/pingcap/tidb/types"
 	"github.com/pingcap/tidb/util/auth"
 	"github.com/pingcap/tidb/util/chunk"
+	"github.com/pingcap/tidb/util/timeutil"
 )
 
 const (
@@ -426,7 +427,7 @@ func (s *SessionVars) GetNextPreparedStmtID() uint32 {
 func (s *SessionVars) Location() *time.Location {
 	loc := s.TimeZone
 	if loc == nil {
-		loc = time.Local
+		loc = timeutil.Local()
 	}
 	return loc
 }

store/mockstore/mocktikv/cop_handler_dag.go

@@ -15,9 +15,7 @@ package mocktikv
 
 import (
 	"bytes"
-	"fmt"
 	"io"
-	"sync"
 	"time"
 
 	"github.com/golang/protobuf/proto"
@@ -37,6 +35,7 @@ import (
 	"github.com/pingcap/tidb/types"
 	"github.com/pingcap/tidb/util/codec"
 	mockpkg "github.com/pingcap/tidb/util/mock"
+	"github.com/pingcap/tidb/util/timeutil"
 	"github.com/pingcap/tipb/go-tipb"
 	"golang.org/x/net/context"
 	"google.golang.org/grpc"
@@ -45,50 +44,6 @@ import (
 
 var dummySlice = make([]byte, 0)
 
-// locCache is a simple map with lock. It stores all used timezone during the lifetime of tidb instance.
-// Talked with Golang team about whether they can have some forms of cache policy available for programmer,
-// they suggests that only programmers knows which one is best for their use case.
-// For detail, please refer to: https://github.com/golang/go/issues/26106
-type locCache struct {
-	sync.RWMutex
-	// locMap stores locations used in past and can be retrieved by a timezone's name.
-	locMap map[string]*time.Location
-}
-
-// init initializes `locCache`.
-func init() {
-	LocCache = &locCache{}
-	LocCache.locMap = make(map[string]*time.Location)
-}
-
-// LocCache is a simple cache policy to improve the performance of 'time.LoadLocation'.
-var LocCache *locCache
-
-// getLoc first trying to load location from a cache map. If nothing found in such map, then call
-// `time.LocadLocation` to get a timezone location. After trying both way, an error wil be returned
-//  if valid Location is not found.
-func (lm *locCache) getLoc(name string) (*time.Location, error) {
-	if name == "System" {
-		name = "Local"
-	}
-	lm.RLock()
-	if v, ok := lm.locMap[name]; ok {
-		lm.RUnlock()
-		return v, nil
-	}
-
-	if loc, err := time.LoadLocation(name); err == nil {
-		lm.RUnlock()
-		lm.Lock()
-		lm.locMap[name] = loc
-		lm.Unlock()
-		return loc, nil
-	}
-
-	lm.RUnlock()
-	return nil, fmt.Errorf("invalid name for timezone %s", name)
-}
-
 type dagContext struct {
 	dagReq    *tipb.DAGRequest
 	keyRanges []*coprocessor.KeyRange
@@ -169,8 +124,9 @@ func (h *rpcHandler) buildDAGExecutor(req *coprocessor.Request) (*dagContext, ex
 // timezone offset in seconds east of UTC is used to constructed the timezone.
 func constructTimeZone(name string, offset int) (*time.Location, error) {
 	if name != "" {
-		return LocCache.getLoc(name)
+		return timeutil.LoadLocation(name)
 	}
+
 	return time.FixedZone("", offset), nil
 }
 

util/logutil/trace.go

@@ -0,0 +1,27 @@
+// Copyright 2018 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package logutil
+
+import (
+	"github.com/opentracing/opentracing-go"
+	"golang.org/x/net/context"
+)
+
+// HasSpan return true if context has an active span
+func HasSpan(ctx context.Context) bool {
+	if sp := opentracing.SpanFromContext(ctx); sp != nil {
+		return true
+	}
+	return false
+}

util/timeutil/time.go

@@ -0,0 +1,134 @@
+// Copyright 2017 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package timeutil
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+
+	log "github.com/sirupsen/logrus"
+)
+
+// init initializes `locCache`.
+func init() {
+	LocCache = &locCache{}
+	LocCache.locMap = make(map[string]*time.Location)
+}
+
+// LocCache is a simple cache policy to improve the performance of 'time.LoadLocation'.
+var LocCache *locCache
+var localStr string
+var localOnce sync.Once
+var zoneSources = []string{
+	"/usr/share/zoneinfo/",
+	"/usr/share/lib/zoneinfo/",
+	"/usr/lib/locale/TZ/",
+}
+
+// locCache is a simple map with lock. It stores all used timezone during the lifetime of tidb instance.
+// Talked with Golang team about whether they can have some forms of cache policy available for programmer,
+// they suggests that only programmers knows which one is best for their use case.
+// For detail, please refer to: https://github.com/golang/go/issues/26106
+type locCache struct {
+	sync.RWMutex
+	// locMap stores locations used in past and can be retrieved by a timezone's name.
+	locMap map[string]*time.Location
+}
+
+func initLocalStr() {
+	// consult $TZ to find the time zone to use.
+	// no $TZ means use the system default /etc/localtime.
+	// $TZ="" means use UTC.
+	// $TZ="foo" means use /usr/share/zoneinfo/foo.
+	tz, ok := syscall.Getenv("TZ")
+	if ok && tz != "" {
+		for _, source := range zoneSources {
+			if _, err := os.Stat(source + tz); os.IsExist(err) {
+				localStr = tz
+				break
+			}
+		}
+		// } else if tz == "" {
+		// localStr = "UTC"
+	} else {
+		path, err := filepath.EvalSymlinks("/etc/localtime")
+		if err == nil {
+			localStr, err = getTZNameFromFileName(path)
+			if err == nil {
+				return
+			}
+			log.Errorln(err)
+		}
+		log.Errorln(err)
+	}
+	localStr = "System"
+}
+
+// getTZNameFromFileName gets IANA timezone name from zoneinfo path.
+// TODO It will be refined later. This is just a quick fix.
+func getTZNameFromFileName(path string) (string, error) {
+	// phase1 only support read /etc/localtime which is a softlink to zoneinfo file
+	substr := "zoneinfo"
+	if strings.Contains(path, substr) {
+		idx := strings.Index(path, substr)
+		return string(path[idx+len(substr)+1:]), nil
+	}
+	return "", errors.New(fmt.Sprintf("path %s is not supported", path))
+}
+
+// Local returns time.Local's IANA timezone name.
+func Local() *time.Location {
+	localOnce.Do(initLocalStr)
+	loc, err := LoadLocation(localStr)
+	if err != nil {
+		return time.Local
+	}
+	return loc
+}
+
+// getLoc first trying to load location from a cache map. If nothing found in such map, then call
+// `time.LocadLocation` to get a timezone location. After trying both way, an error wil be returned
+//  if valid Location is not found.
+func (lm *locCache) getLoc(name string) (*time.Location, error) {
+	if name == "System" {
+		return time.Local, nil
+	}
+	lm.RLock()
+	if v, ok := lm.locMap[name]; ok {
+		lm.RUnlock()
+		return v, nil
+	}
+
+	if loc, err := time.LoadLocation(name); err == nil {
+		lm.RUnlock()
+		lm.Lock()
+		lm.locMap[name] = loc
+		lm.Unlock()
+		return loc, nil
+	}
+
+	lm.RUnlock()
+	return nil, fmt.Errorf("invalid name for timezone %s", name)
+}
+
+// LoadLocation loads time.Location by IANA timezone time.
+func LoadLocation(name string) (*time.Location, error) {
+	return LocCache.getLoc(name)
+}

util/timeutil/time_test.go

@@ -0,0 +1,13 @@
+package timeutil
+
+import (
+	. "github.com/pingcap/check"
+)
+
+type testSuite struct{}
+
+func (s *testSuite) TestgetTZNameFromFileName(c *C) {
+	tz, err := getTZNameFromFileName("/user/share/zoneinfo/Asia/Shanghai")
+	c.Assert(err, IsNil)
+	c.Assert(tz, Equals, "Asia/Shanghai")
+}