Browse Source
Fix error log when loading issues caused by a xorm bug (#7271)
* fix error log when loading issues caused by a xorm bug * upgrade packages * fix fmt * fix Consistency * fix testsfor-closed-social
Lunny Xiao
5 years ago
committed by
Lauris BH
Lauris BH
156 changed files with 1850 additions and 1829 deletions
Split View
Diff Options
-
+8 -9go.mod
-
+15 -11go.sum
-
+1 -1models/action.go
-
+1 -1models/consistency.go
-
+2 -1models/issue.go
-
+1 -1models/issue_comment.go
-
+26 -50models/issue_list.go
-
+1 -1models/issue_reaction.go
-
+1 -1models/issue_tracked_time.go
-
+1 -1models/log.go
-
+1 -1models/login_source.go
-
+1 -1models/migrations/v31.go
-
+1 -1models/migrations/v38.go
-
+1 -1models/migrations/v75.go
-
+1 -1models/migrations/v78.go
-
+1 -1models/migrations/v85.go
-
+1 -1models/models.go
-
+1 -1models/org.go
-
+1 -1models/release.go
-
+1 -1models/repo.go
-
+1 -1models/repo_list.go
-
+1 -1models/repo_unit.go
-
+2 -2models/review.go
-
+1 -1models/ssh_key.go
-
+1 -1models/topic.go
-
+1 -1models/unit_tests.go
-
+2 -2models/user.go
-
+1 -1routers/admin/auths.go
-
+1 -1vendor/github.com/go-sql-driver/mysql/.travis.yml
-
+0 -5vendor/github.com/go-sql-driver/mysql/AUTHORS
-
+11 -0vendor/github.com/go-sql-driver/mysql/CHANGELOG.md
-
+3 -3vendor/github.com/go-sql-driver/mysql/README.md
-
+3 -5vendor/github.com/go-sql-driver/mysql/auth.go
-
+18 -31vendor/github.com/go-sql-driver/mysql/buffer.go
-
+14 -196vendor/github.com/go-sql-driver/mysql/connection.go
-
+207 -0vendor/github.com/go-sql-driver/mysql/connection_go18.go
-
+9 -6vendor/github.com/go-sql-driver/mysql/driver.go
-
+1 -1vendor/github.com/go-sql-driver/mysql/dsn.go
-
+25 -35vendor/github.com/go-sql-driver/mysql/packets.go
-
+1 -30vendor/github.com/go-sql-driver/mysql/utils.go
-
+40 -0vendor/github.com/go-sql-driver/mysql/utils_go17.go
-
+50 -0vendor/github.com/go-sql-driver/mysql/utils_go18.go
-
+0 -1vendor/github.com/go-xorm/builder/go.mod
-
+0 -15vendor/github.com/go-xorm/core/circle.yml
-
+0 -401vendor/github.com/go-xorm/core/db.go
-
+0 -1vendor/github.com/go-xorm/core/go.mod
-
+2 -2vendor/github.com/go-xorm/xorm/.drone.yml
-
+7 -7vendor/github.com/go-xorm/xorm/README.md
-
+5 -5vendor/github.com/go-xorm/xorm/README_CN.md
-
+1 -1vendor/github.com/go-xorm/xorm/cache_lru.go
-
+1 -1vendor/github.com/go-xorm/xorm/cache_memory_store.go
-
+0 -41vendor/github.com/go-xorm/xorm/circle.yml
-
+18 -8vendor/github.com/go-xorm/xorm/dialect_mssql.go
-
+4 -1vendor/github.com/go-xorm/xorm/dialect_mysql.go
-
+1 -1vendor/github.com/go-xorm/xorm/dialect_oracle.go
-
+15 -3vendor/github.com/go-xorm/xorm/dialect_postgres.go
-
+1 -1vendor/github.com/go-xorm/xorm/dialect_sqlite3.go
-
+14 -10vendor/github.com/go-xorm/xorm/engine.go
-
+6 -7vendor/github.com/go-xorm/xorm/engine_cond.go
-
+28 -0vendor/github.com/go-xorm/xorm/engine_context.go
-
+16 -1vendor/github.com/go-xorm/xorm/engine_group.go
-
+2 -2vendor/github.com/go-xorm/xorm/engine_table.go
-
+2 -0vendor/github.com/go-xorm/xorm/error.go
-
+11 -11vendor/github.com/go-xorm/xorm/go.mod
-
+32 -18vendor/github.com/go-xorm/xorm/go.sum
-
+1 -1vendor/github.com/go-xorm/xorm/helpers.go
-
+7 -5vendor/github.com/go-xorm/xorm/interface.go
-
+31 -0vendor/github.com/go-xorm/xorm/json.go
-
+1 -1vendor/github.com/go-xorm/xorm/logger.go
-
+12 -25vendor/github.com/go-xorm/xorm/rows.go
-
+23 -13vendor/github.com/go-xorm/xorm/session.go
-
+1 -1vendor/github.com/go-xorm/xorm/session_cols.go
-
+1 -1vendor/github.com/go-xorm/xorm/session_cond.go
-
+5 -8vendor/github.com/go-xorm/xorm/session_context.go
-
+11 -12vendor/github.com/go-xorm/xorm/session_convert.go
-
+5 -1vendor/github.com/go-xorm/xorm/session_delete.go
-
+14 -4vendor/github.com/go-xorm/xorm/session_exist.go
-
+6 -2vendor/github.com/go-xorm/xorm/session_find.go
-
+5 -1vendor/github.com/go-xorm/xorm/session_get.go
-
+149 -26vendor/github.com/go-xorm/xorm/session_insert.go
-
+4 -0vendor/github.com/go-xorm/xorm/session_iterate.go
-
+13 -13vendor/github.com/go-xorm/xorm/session_query.go
-
+17 -17vendor/github.com/go-xorm/xorm/session_raw.go
-
+2 -2vendor/github.com/go-xorm/xorm/session_schema.go
-
+1 -1vendor/github.com/go-xorm/xorm/session_tx.go
-
+37 -17vendor/github.com/go-xorm/xorm/session_update.go
-
+36 -12vendor/github.com/go-xorm/xorm/statement.go
-
+1 -1vendor/github.com/go-xorm/xorm/syslogger.go
-
+1 -1vendor/github.com/go-xorm/xorm/tag.go
-
+1 -1vendor/github.com/go-xorm/xorm/test_mssql.sh
-
+1 -0vendor/github.com/go-xorm/xorm/test_tidb.sh
-
+5 -1vendor/github.com/go-xorm/xorm/types.go
-
+11 -9vendor/github.com/go-xorm/xorm/xorm.go
-
+14 -3vendor/google.golang.org/appengine/internal/api.go
-
+0 -682vendor/google.golang.org/appengine/internal/api_pre17.go
-
+44 -3vendor/google.golang.org/appengine/internal/identity.go
-
+4 -0vendor/google.golang.org/appengine/internal/identity_classic.go
-
+11 -0vendor/google.golang.org/appengine/internal/identity_flex.go
-
+1 -0vendor/google.golang.org/appengine/internal/main.go
-
+7 -0vendor/google.golang.org/appengine/internal/main_common.go
+ 8
- 9
go.mod
View File
+ 15
- 11
go.sum
View File
+ 1
- 1
models/action.go
View File
+ 1
- 1
models/consistency.go
View File
+ 2
- 1
models/issue.go
View File
+ 1
- 1
models/issue_comment.go
View File
+ 26
- 50
models/issue_list.go
View File
+ 1
- 1
models/issue_reaction.go
View File
+ 1
- 1
models/issue_tracked_time.go
View File
+ 1
- 1
models/log.go
View File
+ 1
- 1
models/login_source.go
View File
+ 1
- 1
models/migrations/v31.go
View File
+ 1
- 1
models/migrations/v38.go
View File
+ 1
- 1
models/migrations/v75.go
View File
+ 1
- 1
models/migrations/v78.go
View File
+ 1
- 1
models/migrations/v85.go
View File
+ 1
- 1
models/models.go
View File
+ 1
- 1
models/org.go
View File
+ 1
- 1
models/release.go
View File
+ 1
- 1
models/repo.go
View File
+ 1
- 1
models/repo_list.go
View File
+ 1
- 1
models/repo_unit.go
View File
+ 2
- 2
models/review.go
View File
+ 1
- 1
models/ssh_key.go
View File
+ 1
- 1
models/topic.go
View File
+ 1
- 1
models/unit_tests.go
View File
+ 2
- 2
models/user.go
View File
+ 1
- 1
routers/admin/auths.go
View File
+ 1
- 1
vendor/github.com/go-sql-driver/mysql/.travis.yml
View File
+ 0
- 5
vendor/github.com/go-sql-driver/mysql/AUTHORS
View File
+ 11
- 0
vendor/github.com/go-sql-driver/mysql/CHANGELOG.md
View File
+ 3
- 3
vendor/github.com/go-sql-driver/mysql/README.md
View File
+ 3
- 5
vendor/github.com/go-sql-driver/mysql/auth.go
View File
+ 18
- 31
vendor/github.com/go-sql-driver/mysql/buffer.go
View File
+ 14
- 196
vendor/github.com/go-sql-driver/mysql/connection.go
View File
+ 207
- 0
vendor/github.com/go-sql-driver/mysql/connection_go18.go
View File
| @ -0,0 +1,207 @@ | |||
| // Go MySQL Driver - A MySQL-Driver for Go's database/sql package | |||
| // | |||
| // Copyright 2012 The Go-MySQL-Driver Authors. All rights reserved. | |||
| // | |||
| // This Source Code Form is subject to the terms of the Mozilla Public | |||
| // License, v. 2.0. If a copy of the MPL was not distributed with this file, | |||
| // You can obtain one at http://mozilla.org/MPL/2.0/. | |||
| // +build go1.8 | |||
| package mysql | |||
| import ( | |||
| "context" | |||
| "database/sql" | |||
| "database/sql/driver" | |||
| ) | |||
| // Ping implements driver.Pinger interface | |||
| func (mc *mysqlConn) Ping(ctx context.Context) (err error) { | |||
| if mc.closed.IsSet() { | |||
| errLog.Print(ErrInvalidConn) | |||
| return driver.ErrBadConn | |||
| } | |||
| if err = mc.watchCancel(ctx); err != nil { | |||
| return | |||
| } | |||
| defer mc.finish() | |||
| if err = mc.writeCommandPacket(comPing); err != nil { | |||
| return | |||
| } | |||
| return mc.readResultOK() | |||
| } | |||
| // BeginTx implements driver.ConnBeginTx interface | |||
| func (mc *mysqlConn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error) { | |||
| if err := mc.watchCancel(ctx); err != nil { | |||
| return nil, err | |||
| } | |||
| defer mc.finish() | |||
| if sql.IsolationLevel(opts.Isolation) != sql.LevelDefault { | |||
| level, err := mapIsolationLevel(opts.Isolation) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| err = mc.exec("SET TRANSACTION ISOLATION LEVEL " + level) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| } | |||
| return mc.begin(opts.ReadOnly) | |||
| } | |||
| func (mc *mysqlConn) QueryContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error) { | |||
| dargs, err := namedValueToValue(args) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| if err := mc.watchCancel(ctx); err != nil { | |||
| return nil, err | |||
| } | |||
| rows, err := mc.query(query, dargs) | |||
| if err != nil { | |||
| mc.finish() | |||
| return nil, err | |||
| } | |||
| rows.finish = mc.finish | |||
| return rows, err | |||
| } | |||
| func (mc *mysqlConn) ExecContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error) { | |||
| dargs, err := namedValueToValue(args) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| if err := mc.watchCancel(ctx); err != nil { | |||
| return nil, err | |||
| } | |||
| defer mc.finish() | |||
| return mc.Exec(query, dargs) | |||
| } | |||
| func (mc *mysqlConn) PrepareContext(ctx context.Context, query string) (driver.Stmt, error) { | |||
| if err := mc.watchCancel(ctx); err != nil { | |||
| return nil, err | |||
| } | |||
| stmt, err := mc.Prepare(query) | |||
| mc.finish() | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| select { | |||
| default: | |||
| case <-ctx.Done(): | |||
| stmt.Close() | |||
| return nil, ctx.Err() | |||
| } | |||
| return stmt, nil | |||
| } | |||
| func (stmt *mysqlStmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) { | |||
| dargs, err := namedValueToValue(args) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| if err := stmt.mc.watchCancel(ctx); err != nil { | |||
| return nil, err | |||
| } | |||
| rows, err := stmt.query(dargs) | |||
| if err != nil { | |||
| stmt.mc.finish() | |||
| return nil, err | |||
| } | |||
| rows.finish = stmt.mc.finish | |||
| return rows, err | |||
| } | |||
| func (stmt *mysqlStmt) ExecContext(ctx context.Context, args []driver.NamedValue) (driver.Result, error) { | |||
| dargs, err := namedValueToValue(args) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| if err := stmt.mc.watchCancel(ctx); err != nil { | |||
| return nil, err | |||
| } | |||
| defer stmt.mc.finish() | |||
| return stmt.Exec(dargs) | |||
| } | |||
| func (mc *mysqlConn) watchCancel(ctx context.Context) error { | |||
| if mc.watching { | |||
| // Reach here if canceled, | |||
| // so the connection is already invalid | |||
| mc.cleanup() | |||
| return nil | |||
| } | |||
| // When ctx is already cancelled, don't watch it. | |||
| if err := ctx.Err(); err != nil { | |||
| return err | |||
| } | |||
| // When ctx is not cancellable, don't watch it. | |||
| if ctx.Done() == nil { | |||
| return nil | |||
| } | |||
| // When watcher is not alive, can't watch it. | |||
| if mc.watcher == nil { | |||
| return nil | |||
| } | |||
| mc.watching = true | |||
| mc.watcher <- ctx | |||
| return nil | |||
| } | |||
| func (mc *mysqlConn) startWatcher() { | |||
| watcher := make(chan mysqlContext, 1) | |||
| mc.watcher = watcher | |||
| finished := make(chan struct{}) | |||
| mc.finished = finished | |||
| go func() { | |||
| for { | |||
| var ctx mysqlContext | |||
| select { | |||
| case ctx = <-watcher: | |||
| case <-mc.closech: | |||
| return | |||
| } | |||
| select { | |||
| case <-ctx.Done(): | |||
| mc.cancel(ctx.Err()) | |||
| case <-finished: | |||
| case <-mc.closech: | |||
| return | |||
| } | |||
| } | |||
| }() | |||
| } | |||
| func (mc *mysqlConn) CheckNamedValue(nv *driver.NamedValue) (err error) { | |||
| nv.Value, err = converter{}.ConvertValue(nv.Value) | |||
| return | |||
| } | |||
| // ResetSession implements driver.SessionResetter. | |||
| // (From Go 1.10) | |||
| func (mc *mysqlConn) ResetSession(ctx context.Context) error { | |||
| if mc.closed.IsSet() { | |||
| return driver.ErrBadConn | |||
| } | |||
| return nil | |||
| } | |||
+ 9
- 6
vendor/github.com/go-sql-driver/mysql/driver.go
View File
+ 1
- 1
vendor/github.com/go-sql-driver/mysql/dsn.go
View File
+ 25
- 35
vendor/github.com/go-sql-driver/mysql/packets.go
View File
+ 1
- 30
vendor/github.com/go-sql-driver/mysql/utils.go
View File
+ 40
- 0
vendor/github.com/go-sql-driver/mysql/utils_go17.go
View File
| @ -0,0 +1,40 @@ | |||
| // Go MySQL Driver - A MySQL-Driver for Go's database/sql package | |||
| // | |||
| // Copyright 2017 The Go-MySQL-Driver Authors. All rights reserved. | |||
| // | |||
| // This Source Code Form is subject to the terms of the Mozilla Public | |||
| // License, v. 2.0. If a copy of the MPL was not distributed with this file, | |||
| // You can obtain one at http://mozilla.org/MPL/2.0/. | |||
| // +build go1.7 | |||
| // +build !go1.8 | |||
| package mysql | |||
| import "crypto/tls" | |||
| func cloneTLSConfig(c *tls.Config) *tls.Config { | |||
| return &tls.Config{ | |||
| Rand: c.Rand, | |||
| Time: c.Time, | |||
| Certificates: c.Certificates, | |||
| NameToCertificate: c.NameToCertificate, | |||
| GetCertificate: c.GetCertificate, | |||
| RootCAs: c.RootCAs, | |||
| NextProtos: c.NextProtos, | |||
| ServerName: c.ServerName, | |||
| ClientAuth: c.ClientAuth, | |||
| ClientCAs: c.ClientCAs, | |||
| InsecureSkipVerify: c.InsecureSkipVerify, | |||
| CipherSuites: c.CipherSuites, | |||
| PreferServerCipherSuites: c.PreferServerCipherSuites, | |||
| SessionTicketsDisabled: c.SessionTicketsDisabled, | |||
| SessionTicketKey: c.SessionTicketKey, | |||
| ClientSessionCache: c.ClientSessionCache, | |||
| MinVersion: c.MinVersion, | |||
| MaxVersion: c.MaxVersion, | |||
| CurvePreferences: c.CurvePreferences, | |||
| DynamicRecordSizingDisabled: c.DynamicRecordSizingDisabled, | |||
| Renegotiation: c.Renegotiation, | |||
| } | |||
| } | |||
+ 50
- 0
vendor/github.com/go-sql-driver/mysql/utils_go18.go
View File
| @ -0,0 +1,50 @@ | |||
| // Go MySQL Driver - A MySQL-Driver for Go's database/sql package | |||
| // | |||
| // Copyright 2017 The Go-MySQL-Driver Authors. All rights reserved. | |||
| // | |||
| // This Source Code Form is subject to the terms of the Mozilla Public | |||
| // License, v. 2.0. If a copy of the MPL was not distributed with this file, | |||
| // You can obtain one at http://mozilla.org/MPL/2.0/. | |||
| // +build go1.8 | |||
| package mysql | |||
| import ( | |||
| "crypto/tls" | |||
| "database/sql" | |||
| "database/sql/driver" | |||
| "errors" | |||
| "fmt" | |||
| ) | |||
| func cloneTLSConfig(c *tls.Config) *tls.Config { | |||
| return c.Clone() | |||
| } | |||
| func namedValueToValue(named []driver.NamedValue) ([]driver.Value, error) { | |||
| dargs := make([]driver.Value, len(named)) | |||
| for n, param := range named { | |||
| if len(param.Name) > 0 { | |||
| // TODO: support the use of Named Parameters #561 | |||
| return nil, errors.New("mysql: driver does not support the use of Named Parameters") | |||
| } | |||
| dargs[n] = param.Value | |||
| } | |||
| return dargs, nil | |||
| } | |||
| func mapIsolationLevel(level driver.IsolationLevel) (string, error) { | |||
| switch sql.IsolationLevel(level) { | |||
| case sql.LevelRepeatableRead: | |||
| return "REPEATABLE READ", nil | |||
| case sql.LevelReadCommitted: | |||
| return "READ COMMITTED", nil | |||
| case sql.LevelReadUncommitted: | |||
| return "READ UNCOMMITTED", nil | |||
| case sql.LevelSerializable: | |||
| return "SERIALIZABLE", nil | |||
| default: | |||
| return "", fmt.Errorf("mysql: unsupported isolation level: %v", level) | |||
| } | |||
| } | |||
+ 0
- 1
vendor/github.com/go-xorm/builder/go.mod
View File
| @ -1 +0,0 @@ | |||
| module "github.com/go-xorm/builder" | |||
+ 0
- 15
vendor/github.com/go-xorm/core/circle.yml
View File
| @ -1,15 +0,0 @@ | |||
| dependencies: | |||
| override: | |||
| # './...' is a relative pattern which means all subdirectories | |||
| - go get -t -d -v ./... | |||
| - go build -v | |||
| database: | |||
| override: | |||
| - mysql -u root -e "CREATE DATABASE core_test DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci" | |||
| test: | |||
| override: | |||
| # './...' is a relative pattern which means all subdirectories | |||
| - go test -v -race | |||
| - go test -v -race --dbtype=sqlite3 | |||
+ 0
- 401
vendor/github.com/go-xorm/core/db.go
View File
| @ -1,401 +0,0 @@ | |||
| package core | |||
| import ( | |||
| "database/sql" | |||
| "database/sql/driver" | |||
| "errors" | |||
| "fmt" | |||
| "reflect" | |||
| "regexp" | |||
| "sync" | |||
| ) | |||
| var ( | |||
| DefaultCacheSize = 200 | |||
| ) | |||
| func MapToSlice(query string, mp interface{}) (string, []interface{}, error) { | |||
| vv := reflect.ValueOf(mp) | |||
| if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Map { | |||
| return "", []interface{}{}, ErrNoMapPointer | |||
| } | |||
| args := make([]interface{}, 0, len(vv.Elem().MapKeys())) | |||
| var err error | |||
| query = re.ReplaceAllStringFunc(query, func(src string) string { | |||
| v := vv.Elem().MapIndex(reflect.ValueOf(src[1:])) | |||
| if !v.IsValid() { | |||
| err = fmt.Errorf("map key %s is missing", src[1:]) | |||
| } else { | |||
| args = append(args, v.Interface()) | |||
| } | |||
| return "?" | |||
| }) | |||
| return query, args, err | |||
| } | |||
| func StructToSlice(query string, st interface{}) (string, []interface{}, error) { | |||
| vv := reflect.ValueOf(st) | |||
| if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Struct { | |||
| return "", []interface{}{}, ErrNoStructPointer | |||
| } | |||
| args := make([]interface{}, 0) | |||
| var err error | |||
| query = re.ReplaceAllStringFunc(query, func(src string) string { | |||
| fv := vv.Elem().FieldByName(src[1:]).Interface() | |||
| if v, ok := fv.(driver.Valuer); ok { | |||
| var value driver.Value | |||
| value, err = v.Value() | |||
| if err != nil { | |||
| return "?" | |||
| } | |||
| args = append(args, value) | |||
| } else { | |||
| args = append(args, fv) | |||
| } | |||
| return "?" | |||
| }) | |||
| if err != nil { | |||
| return "", []interface{}{}, err | |||
| } | |||
| return query, args, nil | |||
| } | |||
| type cacheStruct struct { | |||
| value reflect.Value | |||
| idx int | |||
| } | |||
| type DB struct { | |||
| *sql.DB | |||
| Mapper IMapper | |||
| reflectCache map[reflect.Type]*cacheStruct | |||
| reflectCacheMutex sync.RWMutex | |||
| } | |||
| func Open(driverName, dataSourceName string) (*DB, error) { | |||
| db, err := sql.Open(driverName, dataSourceName) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| return &DB{ | |||
| DB: db, | |||
| Mapper: NewCacheMapper(&SnakeMapper{}), | |||
| reflectCache: make(map[reflect.Type]*cacheStruct), | |||
| }, nil | |||
| } | |||
| func FromDB(db *sql.DB) *DB { | |||
| return &DB{ | |||
| DB: db, | |||
| Mapper: NewCacheMapper(&SnakeMapper{}), | |||
| reflectCache: make(map[reflect.Type]*cacheStruct), | |||
| } | |||
| } | |||
| func (db *DB) reflectNew(typ reflect.Type) reflect.Value { | |||
| db.reflectCacheMutex.Lock() | |||
| defer db.reflectCacheMutex.Unlock() | |||
| cs, ok := db.reflectCache[typ] | |||
| if !ok || cs.idx+1 > DefaultCacheSize-1 { | |||
| cs = &cacheStruct{reflect.MakeSlice(reflect.SliceOf(typ), DefaultCacheSize, DefaultCacheSize), 0} | |||
| db.reflectCache[typ] = cs | |||
| } else { | |||
| cs.idx = cs.idx + 1 | |||
| } | |||
| return cs.value.Index(cs.idx).Addr() | |||
| } | |||
| func (db *DB) Query(query string, args ...interface{}) (*Rows, error) { | |||
| rows, err := db.DB.Query(query, args...) | |||
| if err != nil { | |||
| if rows != nil { | |||
| rows.Close() | |||
| } | |||
| return nil, err | |||
| } | |||
| return &Rows{rows, db}, nil | |||
| } | |||
| func (db *DB) QueryMap(query string, mp interface{}) (*Rows, error) { | |||
| query, args, err := MapToSlice(query, mp) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| return db.Query(query, args...) | |||
| } | |||
| func (db *DB) QueryStruct(query string, st interface{}) (*Rows, error) { | |||
| query, args, err := StructToSlice(query, st) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| return db.Query(query, args...) | |||
| } | |||
| func (db *DB) QueryRow(query string, args ...interface{}) *Row { | |||
| rows, err := db.Query(query, args...) | |||
| if err != nil { | |||
| return &Row{nil, err} | |||
| } | |||
| return &Row{rows, nil} | |||
| } | |||
| func (db *DB) QueryRowMap(query string, mp interface{}) *Row { | |||
| query, args, err := MapToSlice(query, mp) | |||
| if err != nil { | |||
| return &Row{nil, err} | |||
| } | |||
| return db.QueryRow(query, args...) | |||
| } | |||
| func (db *DB) QueryRowStruct(query string, st interface{}) *Row { | |||
| query, args, err := StructToSlice(query, st) | |||
| if err != nil { | |||
| return &Row{nil, err} | |||
| } | |||
| return db.QueryRow(query, args...) | |||
| } | |||
| type Stmt struct { | |||
| *sql.Stmt | |||
| db *DB | |||
| names map[string]int | |||
| } | |||
| func (db *DB) Prepare(query string) (*Stmt, error) { | |||
| names := make(map[string]int) | |||
| var i int | |||
| query = re.ReplaceAllStringFunc(query, func(src string) string { | |||
| names[src[1:]] = i | |||
| i += 1 | |||
| return "?" | |||
| }) | |||
| stmt, err := db.DB.Prepare(query) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| return &Stmt{stmt, db, names}, nil | |||
| } | |||
| func (s *Stmt) ExecMap(mp interface{}) (sql.Result, error) { | |||
| vv := reflect.ValueOf(mp) | |||
| if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Map { | |||
| return nil, errors.New("mp should be a map's pointer") | |||
| } | |||
| args := make([]interface{}, len(s.names)) | |||
| for k, i := range s.names { | |||
| args[i] = vv.Elem().MapIndex(reflect.ValueOf(k)).Interface() | |||
| } | |||
| return s.Stmt.Exec(args...) | |||
| } | |||
| func (s *Stmt) ExecStruct(st interface{}) (sql.Result, error) { | |||
| vv := reflect.ValueOf(st) | |||
| if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Struct { | |||
| return nil, errors.New("mp should be a map's pointer") | |||
| } | |||
| args := make([]interface{}, len(s.names)) | |||
| for k, i := range s.names { | |||
| args[i] = vv.Elem().FieldByName(k).Interface() | |||
| } | |||
| return s.Stmt.Exec(args...) | |||
| } | |||
| func (s *Stmt) Query(args ...interface{}) (*Rows, error) { | |||
| rows, err := s.Stmt.Query(args...) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| return &Rows{rows, s.db}, nil | |||
| } | |||
| func (s *Stmt) QueryMap(mp interface{}) (*Rows, error) { | |||
| vv := reflect.ValueOf(mp) | |||
| if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Map { | |||
| return nil, errors.New("mp should be a map's pointer") | |||
| } | |||
| args := make([]interface{}, len(s.names)) | |||
| for k, i := range s.names { | |||
| args[i] = vv.Elem().MapIndex(reflect.ValueOf(k)).Interface() | |||
| } | |||
| return s.Query(args...) | |||
| } | |||
| func (s *Stmt) QueryStruct(st interface{}) (*Rows, error) { | |||
| vv := reflect.ValueOf(st) | |||
| if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Struct { | |||
| return nil, errors.New("mp should be a map's pointer") | |||
| } | |||
| args := make([]interface{}, len(s.names)) | |||
| for k, i := range s.names { | |||
| args[i] = vv.Elem().FieldByName(k).Interface() | |||
| } | |||
| return s.Query(args...) | |||
| } | |||
| func (s *Stmt) QueryRow(args ...interface{}) *Row { | |||
| rows, err := s.Query(args...) | |||
| return &Row{rows, err} | |||
| } | |||
| func (s *Stmt) QueryRowMap(mp interface{}) *Row { | |||
| vv := reflect.ValueOf(mp) | |||
| if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Map { | |||
| return &Row{nil, errors.New("mp should be a map's pointer")} | |||
| } | |||
| args := make([]interface{}, len(s.names)) | |||
| for k, i := range s.names { | |||
| args[i] = vv.Elem().MapIndex(reflect.ValueOf(k)).Interface() | |||
| } | |||
| return s.QueryRow(args...) | |||
| } | |||
| func (s *Stmt) QueryRowStruct(st interface{}) *Row { | |||
| vv := reflect.ValueOf(st) | |||
| if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Struct { | |||
| return &Row{nil, errors.New("st should be a struct's pointer")} | |||
| } | |||
| args := make([]interface{}, len(s.names)) | |||
| for k, i := range s.names { | |||
| args[i] = vv.Elem().FieldByName(k).Interface() | |||
| } | |||
| return s.QueryRow(args...) | |||
| } | |||
| var ( | |||
| re = regexp.MustCompile(`[?](\w+)`) | |||
| ) | |||
| // insert into (name) values (?) | |||
| // insert into (name) values (?name) | |||
| func (db *DB) ExecMap(query string, mp interface{}) (sql.Result, error) { | |||
| query, args, err := MapToSlice(query, mp) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| return db.DB.Exec(query, args...) | |||
| } | |||
| func (db *DB) ExecStruct(query string, st interface{}) (sql.Result, error) { | |||
| query, args, err := StructToSlice(query, st) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| return db.DB.Exec(query, args...) | |||
| } | |||
| type EmptyScanner struct { | |||
| } | |||
| func (EmptyScanner) Scan(src interface{}) error { | |||
| return nil | |||
| } | |||
| type Tx struct { | |||
| *sql.Tx | |||
| db *DB | |||
| } | |||
| func (db *DB) Begin() (*Tx, error) { | |||
| tx, err := db.DB.Begin() | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| return &Tx{tx, db}, nil | |||
| } | |||
| func (tx *Tx) Prepare(query string) (*Stmt, error) { | |||
| names := make(map[string]int) | |||
| var i int | |||
| query = re.ReplaceAllStringFunc(query, func(src string) string { | |||
| names[src[1:]] = i | |||
| i += 1 | |||
| return "?" | |||
| }) | |||
| stmt, err := tx.Tx.Prepare(query) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| return &Stmt{stmt, tx.db, names}, nil | |||
| } | |||
| func (tx *Tx) Stmt(stmt *Stmt) *Stmt { | |||
| // TODO: | |||
| return stmt | |||
| } | |||
| func (tx *Tx) ExecMap(query string, mp interface{}) (sql.Result, error) { | |||
| query, args, err := MapToSlice(query, mp) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| return tx.Tx.Exec(query, args...) | |||
| } | |||
| func (tx *Tx) ExecStruct(query string, st interface{}) (sql.Result, error) { | |||
| query, args, err := StructToSlice(query, st) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| return tx.Tx.Exec(query, args...) | |||
| } | |||
| func (tx *Tx) Query(query string, args ...interface{}) (*Rows, error) { | |||
| rows, err := tx.Tx.Query(query, args...) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| return &Rows{rows, tx.db}, nil | |||
| } | |||
| func (tx *Tx) QueryMap(query string, mp interface{}) (*Rows, error) { | |||
| query, args, err := MapToSlice(query, mp) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| return tx.Query(query, args...) | |||
| } | |||
| func (tx *Tx) QueryStruct(query string, st interface{}) (*Rows, error) { | |||
| query, args, err := StructToSlice(query, st) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| return tx.Query(query, args...) | |||
| } | |||
| func (tx *Tx) QueryRow(query string, args ...interface{}) *Row { | |||
| rows, err := tx.Query(query, args...) | |||
| return &Row{rows, err} | |||
| } | |||
| func (tx *Tx) QueryRowMap(query string, mp interface{}) *Row { | |||
| query, args, err := MapToSlice(query, mp) | |||
| if err != nil { | |||
| return &Row{nil, err} | |||
| } | |||
| return tx.QueryRow(query, args...) | |||
| } | |||
| func (tx *Tx) QueryRowStruct(query string, st interface{}) *Row { | |||
| query, args, err := StructToSlice(query, st) | |||
| if err != nil { | |||
| return &Row{nil, err} | |||
| } | |||
| return tx.QueryRow(query, args...) | |||
| } | |||
+ 0
- 1
vendor/github.com/go-xorm/core/go.mod
View File
| @ -1 +0,0 @@ | |||
| module "github.com/go-xorm/core" | |||
+ 2
- 2
vendor/github.com/go-xorm/xorm/.drone.yml
View File
+ 7
- 7
vendor/github.com/go-xorm/xorm/README.md
View File
+ 5
- 5
vendor/github.com/go-xorm/xorm/README_CN.md
View File
+ 1
- 1
vendor/github.com/go-xorm/xorm/cache_lru.go
View File
+ 1
- 1
vendor/github.com/go-xorm/xorm/cache_memory_store.go
View File
+ 0
- 41
vendor/github.com/go-xorm/xorm/circle.yml
View File
| @ -1,41 +0,0 @@ | |||
| dependencies: | |||
| override: | |||
| # './...' is a relative pattern which means all subdirectories | |||
| - go get -t -d -v ./... | |||
| - go get -t -d -v github.com/go-xorm/tests | |||
| - go get -u github.com/go-xorm/core | |||
| - go get -u github.com/go-xorm/builder | |||
| - go build -v | |||
| database: | |||
| override: | |||
| - mysql -u root -e "CREATE DATABASE xorm_test DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci" | |||
| - mysql -u root -e "CREATE DATABASE xorm_test1 DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci" | |||
| - mysql -u root -e "CREATE DATABASE xorm_test2 DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci" | |||
| - mysql -u root -e "CREATE DATABASE xorm_test3 DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci" | |||
| - createdb -p 5432 -e -U postgres xorm_test | |||
| - createdb -p 5432 -e -U postgres xorm_test1 | |||
| - createdb -p 5432 -e -U postgres xorm_test2 | |||
| - createdb -p 5432 -e -U postgres xorm_test3 | |||
| - psql xorm_test postgres -c "create schema xorm" | |||
| test: | |||
| override: | |||
| # './...' is a relative pattern which means all subdirectories | |||
| - go get -u github.com/wadey/gocovmerge | |||
| - go test -v -race -db="sqlite3" -conn_str="./test.db" -coverprofile=coverage1-1.txt -covermode=atomic | |||
| - go test -v -race -db="sqlite3" -conn_str="./test.db" -cache=true -coverprofile=coverage1-2.txt -covermode=atomic | |||
| - go test -v -race -db="mysql" -conn_str="root:@/xorm_test" -coverprofile=coverage2-1.txt -covermode=atomic | |||
| - go test -v -race -db="mysql" -conn_str="root:@/xorm_test" -cache=true -coverprofile=coverage2-2.txt -covermode=atomic | |||
| - go test -v -race -db="mymysql" -conn_str="xorm_test/root/" -coverprofile=coverage3-1.txt -covermode=atomic | |||
| - go test -v -race -db="mymysql" -conn_str="xorm_test/root/" -cache=true -coverprofile=coverage3-2.txt -covermode=atomic | |||
| - go test -v -race -db="postgres" -conn_str="dbname=xorm_test sslmode=disable" -coverprofile=coverage4-1.txt -covermode=atomic | |||
| - go test -v -race -db="postgres" -conn_str="dbname=xorm_test sslmode=disable" -cache=true -coverprofile=coverage4-2.txt -covermode=atomic | |||
| - go test -v -race -db="postgres" -conn_str="dbname=xorm_test sslmode=disable" -schema=xorm -coverprofile=coverage5-1.txt -covermode=atomic | |||
| - go test -v -race -db="postgres" -conn_str="dbname=xorm_test sslmode=disable" -schema=xorm -cache=true -coverprofile=coverage5-2.txt -covermode=atomic | |||
| - gocovmerge coverage1-1.txt coverage1-2.txt coverage2-1.txt coverage2-2.txt coverage3-1.txt coverage3-2.txt coverage4-1.txt coverage4-2.txt coverage5-1.txt coverage5-2.txt > coverage.txt | |||
| - cd /home/ubuntu/.go_workspace/src/github.com/go-xorm/tests && ./sqlite3.sh | |||
| - cd /home/ubuntu/.go_workspace/src/github.com/go-xorm/tests && ./mysql.sh | |||
| - cd /home/ubuntu/.go_workspace/src/github.com/go-xorm/tests && ./postgres.sh | |||
| post: | |||
| - bash <(curl -s https://codecov.io/bash) | |||
+ 18
- 8
vendor/github.com/go-xorm/xorm/dialect_mssql.go
View File
+ 4
- 1
vendor/github.com/go-xorm/xorm/dialect_mysql.go
View File
+ 1
- 1
vendor/github.com/go-xorm/xorm/dialect_oracle.go
View File
+ 15
- 3
vendor/github.com/go-xorm/xorm/dialect_postgres.go
View File
+ 1
- 1
vendor/github.com/go-xorm/xorm/dialect_sqlite3.go
View File
+ 14
- 10
vendor/github.com/go-xorm/xorm/engine.go
View File
+ 6
- 7
vendor/github.com/go-xorm/xorm/engine_cond.go
View File
+ 28
- 0
vendor/github.com/go-xorm/xorm/engine_context.go
View File
| @ -0,0 +1,28 @@ | |||
| // Copyright 2019 The Xorm Authors. All rights reserved. | |||
| // Use of this source code is governed by a BSD-style | |||
| // license that can be found in the LICENSE file. | |||
| // +build go1.8 | |||
| package xorm | |||
| import "context" | |||
| // Context creates a session with the context | |||
| func (engine *Engine) Context(ctx context.Context) *Session { | |||
| session := engine.NewSession() | |||
| session.isAutoClose = true | |||
| return session.Context(ctx) | |||
| } | |||
| // SetDefaultContext set the default context | |||
| func (engine *Engine) SetDefaultContext(ctx context.Context) { | |||
| engine.defaultContext = ctx | |||
| } | |||
| // PingContext tests if database is alive | |||
| func (engine *Engine) PingContext(ctx context.Context) error { | |||
| session := engine.NewSession() | |||
| defer session.Close() | |||
| return session.PingContext(ctx) | |||
| } | |||
+ 16
- 1
vendor/github.com/go-xorm/xorm/engine_group.go
View File
+ 2
- 2
vendor/github.com/go-xorm/xorm/engine_table.go
View File
+ 2
- 0
vendor/github.com/go-xorm/xorm/error.go
View File
+ 11
- 11
vendor/github.com/go-xorm/xorm/go.mod
View File
| @ -1,24 +1,24 @@ | |||
| module github.com/go-xorm/xorm | |||
| require ( | |||
| cloud.google.com/go v0.34.0 // indirect | |||
| github.com/cockroachdb/apd v1.1.0 // indirect | |||
| github.com/davecgh/go-spew v1.1.1 // indirect | |||
| github.com/denisenkom/go-mssqldb v0.0.0-20181014144952-4e0d7dc8888f | |||
| github.com/go-sql-driver/mysql v1.4.0 | |||
| github.com/go-xorm/builder v0.3.2 | |||
| github.com/go-xorm/core v0.6.0 | |||
| github.com/go-xorm/sqlfiddle v0.0.0-20180821085327-62ce714f951a // indirect | |||
| github.com/denisenkom/go-mssqldb v0.0.0-20190121005146-b04fd42d9952 | |||
| github.com/go-sql-driver/mysql v1.4.1 | |||
| github.com/google/go-cmp v0.2.0 // indirect | |||
| github.com/jackc/fake v0.0.0-20150926172116-812a484cc733 // indirect | |||
| github.com/jackc/pgx v3.2.0+incompatible | |||
| github.com/jackc/pgx v3.3.0+incompatible | |||
| github.com/kr/pretty v0.1.0 // indirect | |||
| github.com/lib/pq v1.0.0 | |||
| github.com/mattn/go-sqlite3 v1.9.0 | |||
| github.com/pkg/errors v0.8.0 // indirect | |||
| github.com/pmezard/go-difflib v1.0.0 // indirect | |||
| github.com/mattn/go-sqlite3 v1.10.0 | |||
| github.com/pkg/errors v0.8.1 // indirect | |||
| github.com/satori/go.uuid v1.2.0 // indirect | |||
| github.com/shopspring/decimal v0.0.0-20180709203117-cd690d0c9e24 // indirect | |||
| github.com/stretchr/testify v1.2.2 | |||
| github.com/stretchr/testify v1.3.0 | |||
| github.com/ziutek/mymysql v1.5.4 | |||
| golang.org/x/crypto v0.0.0-20190122013713-64072686203f // indirect | |||
| gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect | |||
| gopkg.in/stretchr/testify.v1 v1.2.2 | |||
| xorm.io/builder v0.3.5 | |||
| xorm.io/core v0.6.3 | |||
| ) | |||
+ 32
- 18
vendor/github.com/go-xorm/xorm/go.sum
View File
+ 1
- 1
vendor/github.com/go-xorm/xorm/helpers.go
View File
+ 7
- 5
vendor/github.com/go-xorm/xorm/interface.go
View File
+ 31
- 0
vendor/github.com/go-xorm/xorm/json.go
View File
| @ -0,0 +1,31 @@ | |||
| // Copyright 2019 The Xorm Authors. All rights reserved. | |||
| // Use of this source code is governed by a BSD-style | |||
| // license that can be found in the LICENSE file. | |||
| package xorm | |||
| import "encoding/json" | |||
| // JSONInterface represents an interface to handle json data | |||
| type JSONInterface interface { | |||
| Marshal(v interface{}) ([]byte, error) | |||
| Unmarshal(data []byte, v interface{}) error | |||
| } | |||
| var ( | |||
| // DefaultJSONHandler default json handler | |||
| DefaultJSONHandler JSONInterface = StdJSON{} | |||
| ) | |||
| // StdJSON implements JSONInterface via encoding/json | |||
| type StdJSON struct{} | |||
| // Marshal implements JSONInterface | |||
| func (StdJSON) Marshal(v interface{}) ([]byte, error) { | |||
| return json.Marshal(v) | |||
| } | |||
| // Unmarshal implements JSONInterface | |||
| func (StdJSON) Unmarshal(data []byte, v interface{}) error { | |||
| return json.Unmarshal(data, v) | |||
| } | |||
+ 1
- 1
vendor/github.com/go-xorm/xorm/logger.go
View File
+ 12
- 25
vendor/github.com/go-xorm/xorm/rows.go
View File
+ 23
- 13
vendor/github.com/go-xorm/xorm/session.go
View File
+ 1
- 1
vendor/github.com/go-xorm/xorm/session_cols.go
View File
+ 1
- 1
vendor/github.com/go-xorm/xorm/session_cond.go
View File
vendor/github.com/go-xorm/xorm/context.go → vendor/github.com/go-xorm/xorm/session_context.go
View File
| @ -1,18 +1,15 @@ | |||
| // Copyright 2017 The Xorm Authors. All rights reserved. | |||
| // Copyright 2019 The Xorm Authors. All rights reserved. | |||
| // Use of this source code is governed by a BSD-style | |||
| // license that can be found in the LICENSE file. | |||
| // +build go1.8 | |||
| package xorm | |||
| import "context" | |||
| // PingContext tests if database is alive | |||
| func (engine *Engine) PingContext(ctx context.Context) error { | |||
| session := engine.NewSession() | |||
| defer session.Close() | |||
| return session.PingContext(ctx) | |||
| // Context sets the context on this session | |||
| func (session *Session) Context(ctx context.Context) *Session { | |||
| session.ctx = ctx | |||
| return session | |||
| } | |||
| // PingContext test if database is ok | |||
+ 11
- 12
vendor/github.com/go-xorm/xorm/session_convert.go
View File
+ 5
- 1
vendor/github.com/go-xorm/xorm/session_delete.go
View File
+ 14
- 4
vendor/github.com/go-xorm/xorm/session_exist.go
View File
+ 6
- 2
vendor/github.com/go-xorm/xorm/session_find.go
View File
+ 5
- 1
vendor/github.com/go-xorm/xorm/session_get.go
View File
+ 149
- 26
vendor/github.com/go-xorm/xorm/session_insert.go
View File
+ 4
- 0
vendor/github.com/go-xorm/xorm/session_iterate.go
View File
+ 13
- 13
vendor/github.com/go-xorm/xorm/session_query.go
View File
+ 17
- 17
vendor/github.com/go-xorm/xorm/session_raw.go
View File
+ 2
- 2
vendor/github.com/go-xorm/xorm/session_schema.go
View File
+ 1
- 1
vendor/github.com/go-xorm/xorm/session_tx.go
View File
+ 37
- 17
vendor/github.com/go-xorm/xorm/session_update.go
View File
+ 36
- 12
vendor/github.com/go-xorm/xorm/statement.go
View File
+ 1
- 1
vendor/github.com/go-xorm/xorm/syslogger.go
View File
+ 1
- 1
vendor/github.com/go-xorm/xorm/tag.go
View File
+ 1
- 1
vendor/github.com/go-xorm/xorm/test_mssql.sh
View File
| @ -1 +1 @@ | |||
| go test -db=mssql -conn_str="server=192.168.1.58;user id=sa;password=123456;database=xorm_test" | |||
| go test -db=mssql -conn_str="server=localhost;user id=sa;password=yourStrong(!)Password;database=xorm_test" | |||
+ 1
- 0
vendor/github.com/go-xorm/xorm/test_tidb.sh
View File
| @ -0,0 +1 @@ | |||
| go test -db=mysql -conn_str="root:@tcp(localhost:4000)/xorm_test" -ignore_select_update=true | |||
+ 5
- 1
vendor/github.com/go-xorm/xorm/types.go
View File
+ 11
- 9
vendor/github.com/go-xorm/xorm/xorm.go
View File
+ 14
- 3
vendor/google.golang.org/appengine/internal/api.go
View File
+ 0
- 682
vendor/google.golang.org/appengine/internal/api_pre17.go
View File
| @ -1,682 +0,0 @@ | |||
| // Copyright 2011 Google Inc. All rights reserved. | |||
| // Use of this source code is governed by the Apache 2.0 | |||
| // license that can be found in the LICENSE file. | |||
| // +build !appengine | |||
| // +build !go1.7 | |||
| package internal | |||
| import ( | |||
| "bytes" | |||
| "errors" | |||
| "fmt" | |||
| "io/ioutil" | |||
| "log" | |||
| "net" | |||
| "net/http" | |||
| "net/url" | |||
| "os" | |||
| "runtime" | |||
| "strconv" | |||
| "strings" | |||
| "sync" | |||
| "sync/atomic" | |||
| "time" | |||
| "github.com/golang/protobuf/proto" | |||
| netcontext "golang.org/x/net/context" | |||
| basepb "google.golang.org/appengine/internal/base" | |||
| logpb "google.golang.org/appengine/internal/log" | |||
| remotepb "google.golang.org/appengine/internal/remote_api" | |||
| ) | |||
| const ( | |||
| apiPath = "/rpc_http" | |||
| defaultTicketSuffix = "/default.20150612t184001.0" | |||
| ) | |||
| var ( | |||
| // Incoming headers. | |||
| ticketHeader = http.CanonicalHeaderKey("X-AppEngine-API-Ticket") | |||
| dapperHeader = http.CanonicalHeaderKey("X-Google-DapperTraceInfo") | |||
| traceHeader = http.CanonicalHeaderKey("X-Cloud-Trace-Context") | |||
| curNamespaceHeader = http.CanonicalHeaderKey("X-AppEngine-Current-Namespace") | |||
| userIPHeader = http.CanonicalHeaderKey("X-AppEngine-User-IP") | |||
| remoteAddrHeader = http.CanonicalHeaderKey("X-AppEngine-Remote-Addr") | |||
| // Outgoing headers. | |||
| apiEndpointHeader = http.CanonicalHeaderKey("X-Google-RPC-Service-Endpoint") | |||
| apiEndpointHeaderValue = []string{"app-engine-apis"} | |||
| apiMethodHeader = http.CanonicalHeaderKey("X-Google-RPC-Service-Method") | |||
| apiMethodHeaderValue = []string{"/VMRemoteAPI.CallRemoteAPI"} | |||
| apiDeadlineHeader = http.CanonicalHeaderKey("X-Google-RPC-Service-Deadline") | |||
| apiContentType = http.CanonicalHeaderKey("Content-Type") | |||
| apiContentTypeValue = []string{"application/octet-stream"} | |||
| logFlushHeader = http.CanonicalHeaderKey("X-AppEngine-Log-Flush-Count") | |||
| apiHTTPClient = &http.Client{ | |||
| Transport: &http.Transport{ | |||
| Proxy: http.ProxyFromEnvironment, | |||
| Dial: limitDial, | |||
| }, | |||
| } | |||
| defaultTicketOnce sync.Once | |||
| defaultTicket string | |||
| ) | |||
| func apiURL() *url.URL { | |||
| host, port := "appengine.googleapis.internal", "10001" | |||
| if h := os.Getenv("API_HOST"); h != "" { | |||
| host = h | |||
| } | |||
| if p := os.Getenv("API_PORT"); p != "" { | |||
| port = p | |||
| } | |||
| return &url.URL{ | |||
| Scheme: "http", | |||
| Host: host + ":" + port, | |||
| Path: apiPath, | |||
| } | |||
| } | |||
| func handleHTTP(w http.ResponseWriter, r *http.Request) { | |||
| c := &context{ | |||
| req: r, | |||
| outHeader: w.Header(), | |||
| apiURL: apiURL(), | |||
| } | |||
| stopFlushing := make(chan int) | |||
| ctxs.Lock() | |||
| ctxs.m[r] = c | |||
| ctxs.Unlock() | |||
| defer func() { | |||
| ctxs.Lock() | |||
| delete(ctxs.m, r) | |||
| ctxs.Unlock() | |||
| }() | |||
| // Patch up RemoteAddr so it looks reasonable. | |||
| if addr := r.Header.Get(userIPHeader); addr != "" { | |||
| r.RemoteAddr = addr | |||
| } else if addr = r.Header.Get(remoteAddrHeader); addr != "" { | |||
| r.RemoteAddr = addr | |||
| } else { | |||
| // Should not normally reach here, but pick a sensible default anyway. | |||
| r.RemoteAddr = "127.0.0.1" | |||
| } | |||
| // The address in the headers will most likely be of these forms: | |||
| // 123.123.123.123 | |||
| // 2001:db8::1 | |||
| // net/http.Request.RemoteAddr is specified to be in "IP:port" form. | |||
| if _, _, err := net.SplitHostPort(r.RemoteAddr); err != nil { | |||
| // Assume the remote address is only a host; add a default port. | |||
| r.RemoteAddr = net.JoinHostPort(r.RemoteAddr, "80") | |||
| } | |||
| // Start goroutine responsible for flushing app logs. | |||
| // This is done after adding c to ctx.m (and stopped before removing it) | |||
| // because flushing logs requires making an API call. | |||
| go c.logFlusher(stopFlushing) | |||
| executeRequestSafely(c, r) | |||
| c.outHeader = nil // make sure header changes aren't respected any more | |||
| stopFlushing <- 1 // any logging beyond this point will be dropped | |||
| // Flush any pending logs asynchronously. | |||
| c.pendingLogs.Lock() | |||
| flushes := c.pendingLogs.flushes | |||
| if len(c.pendingLogs.lines) > 0 { | |||
| flushes++ | |||
| } | |||
| c.pendingLogs.Unlock() | |||
| go c.flushLog(false) | |||
| w.Header().Set(logFlushHeader, strconv.Itoa(flushes)) | |||
| // Avoid nil Write call if c.Write is never called. | |||
| if c.outCode != 0 { | |||
| w.WriteHeader(c.outCode) | |||
| } | |||
| if c.outBody != nil { | |||
| w.Write(c.outBody) | |||
| } | |||
| } | |||
| func executeRequestSafely(c *context, r *http.Request) { | |||
| defer func() { | |||
| if x := recover(); x != nil { | |||
| logf(c, 4, "%s", renderPanic(x)) // 4 == critical | |||
| c.outCode = 500 | |||
| } | |||
| }() | |||
| http.DefaultServeMux.ServeHTTP(c, r) | |||
| } | |||
| func renderPanic(x interface{}) string { | |||
| buf := make([]byte, 16<<10) // 16 KB should be plenty | |||
| buf = buf[:runtime.Stack(buf, false)] | |||
| // Remove the first few stack frames: | |||
| // this func | |||
| // the recover closure in the caller | |||
| // That will root the stack trace at the site of the panic. | |||
| const ( | |||
| skipStart = "internal.renderPanic" | |||
| skipFrames = 2 | |||
| ) | |||
| start := bytes.Index(buf, []byte(skipStart)) | |||
| p := start | |||
| for i := 0; i < skipFrames*2 && p+1 < len(buf); i++ { | |||
| p = bytes.IndexByte(buf[p+1:], '\n') + p + 1 | |||
| if p < 0 { | |||
| break | |||
| } | |||
| } | |||
| if p >= 0 { | |||
| // buf[start:p+1] is the block to remove. | |||
| // Copy buf[p+1:] over buf[start:] and shrink buf. | |||
| copy(buf[start:], buf[p+1:]) | |||
| buf = buf[:len(buf)-(p+1-start)] | |||
| } | |||
| // Add panic heading. | |||
| head := fmt.Sprintf("panic: %v\n\n", x) | |||
| if len(head) > len(buf) { | |||
| // Extremely unlikely to happen. | |||
| return head | |||
| } | |||
| copy(buf[len(head):], buf) | |||
| copy(buf, head) | |||
| return string(buf) | |||
| } | |||
| var ctxs = struct { | |||
| sync.Mutex | |||
| m map[*http.Request]*context | |||
| bg *context // background context, lazily initialized | |||
| // dec is used by tests to decorate the netcontext.Context returned | |||
| // for a given request. This allows tests to add overrides (such as | |||
| // WithAppIDOverride) to the context. The map is nil outside tests. | |||
| dec map[*http.Request]func(netcontext.Context) netcontext.Context | |||
| }{ | |||
| m: make(map[*http.Request]*context), | |||
| } | |||
| // context represents the context of an in-flight HTTP request. | |||
| // It implements the appengine.Context and http.ResponseWriter interfaces. | |||
| type context struct { | |||
| req *http.Request | |||
| outCode int | |||
| outHeader http.Header | |||
| outBody []byte | |||
| pendingLogs struct { | |||
| sync.Mutex | |||
| lines []*logpb.UserAppLogLine | |||
| flushes int | |||
| } | |||
| apiURL *url.URL | |||
| } | |||
| var contextKey = "holds a *context" | |||
| // fromContext returns the App Engine context or nil if ctx is not | |||
| // derived from an App Engine context. | |||
| func fromContext(ctx netcontext.Context) *context { | |||
| c, _ := ctx.Value(&contextKey).(*context) | |||
| return c | |||
| } | |||
| func withContext(parent netcontext.Context, c *context) netcontext.Context { | |||
| ctx := netcontext.WithValue(parent, &contextKey, c) | |||
| if ns := c.req.Header.Get(curNamespaceHeader); ns != "" { | |||
| ctx = withNamespace(ctx, ns) | |||
| } | |||
| return ctx | |||
| } | |||
| func toContext(c *context) netcontext.Context { | |||
| return withContext(netcontext.Background(), c) | |||
| } | |||
| func IncomingHeaders(ctx netcontext.Context) http.Header { | |||
| if c := fromContext(ctx); c != nil { | |||
| return c.req.Header | |||
| } | |||
| return nil | |||
| } | |||
| func ReqContext(req *http.Request) netcontext.Context { | |||
| return WithContext(netcontext.Background(), req) | |||
| } | |||
| func WithContext(parent netcontext.Context, req *http.Request) netcontext.Context { | |||
| ctxs.Lock() | |||
| c := ctxs.m[req] | |||
| d := ctxs.dec[req] | |||
| ctxs.Unlock() | |||
| if d != nil { | |||
| parent = d(parent) | |||
| } | |||
| if c == nil { | |||
| // Someone passed in an http.Request that is not in-flight. | |||
| // We panic here rather than panicking at a later point | |||
| // so that stack traces will be more sensible. | |||
| log.Panic("appengine: NewContext passed an unknown http.Request") | |||
| } | |||
| return withContext(parent, c) | |||
| } | |||
| // DefaultTicket returns a ticket used for background context or dev_appserver. | |||
| func DefaultTicket() string { | |||
| defaultTicketOnce.Do(func() { | |||
| if IsDevAppServer() { | |||
| defaultTicket = "testapp" + defaultTicketSuffix | |||
| return | |||
| } | |||
| appID := partitionlessAppID() | |||
| escAppID := strings.Replace(strings.Replace(appID, ":", "_", -1), ".", "_", -1) | |||
| majVersion := VersionID(nil) | |||
| if i := strings.Index(majVersion, "."); i > 0 { | |||
| majVersion = majVersion[:i] | |||
| } | |||
| defaultTicket = fmt.Sprintf("%s/%s.%s.%s", escAppID, ModuleName(nil), majVersion, InstanceID()) | |||
| }) | |||
| return defaultTicket | |||
| } | |||
| func BackgroundContext() netcontext.Context { | |||
| ctxs.Lock() | |||
| defer ctxs.Unlock() | |||
| if ctxs.bg != nil { | |||
| return toContext(ctxs.bg) | |||
| } | |||
| // Compute background security ticket. | |||
| ticket := DefaultTicket() | |||
| ctxs.bg = &context{ | |||
| req: &http.Request{ | |||
| Header: http.Header{ | |||
| ticketHeader: []string{ticket}, | |||
| }, | |||
| }, | |||
| apiURL: apiURL(), | |||
| } | |||
| // TODO(dsymonds): Wire up the shutdown handler to do a final flush. | |||
| go ctxs.bg.logFlusher(make(chan int)) | |||
| return toContext(ctxs.bg) | |||
| } | |||
| // RegisterTestRequest registers the HTTP request req for testing, such that | |||
| // any API calls are sent to the provided URL. It returns a closure to delete | |||
| // the registration. | |||
| // It should only be used by aetest package. | |||
| func RegisterTestRequest(req *http.Request, apiURL *url.URL, decorate func(netcontext.Context) netcontext.Context) (*http.Request, func()) { | |||
| c := &context{ | |||
| req: req, | |||
| apiURL: apiURL, | |||
| } | |||
| ctxs.Lock() | |||
| defer ctxs.Unlock() | |||
| if _, ok := ctxs.m[req]; ok { | |||
| log.Panic("req already associated with context") | |||
| } | |||
| if _, ok := ctxs.dec[req]; ok { | |||
| log.Panic("req already associated with context") | |||
| } | |||
| if ctxs.dec == nil { | |||
| ctxs.dec = make(map[*http.Request]func(netcontext.Context) netcontext.Context) | |||
| } | |||
| ctxs.m[req] = c | |||
| ctxs.dec[req] = decorate | |||
| return req, func() { | |||
| ctxs.Lock() | |||
| delete(ctxs.m, req) | |||
| delete(ctxs.dec, req) | |||
| ctxs.Unlock() | |||
| } | |||
| } | |||
| var errTimeout = &CallError{ | |||
| Detail: "Deadline exceeded", | |||
| Code: int32(remotepb.RpcError_CANCELLED), | |||
| Timeout: true, | |||
| } | |||
| func (c *context) Header() http.Header { return c.outHeader } | |||
| // Copied from $GOROOT/src/pkg/net/http/transfer.go. Some response status | |||
| // codes do not permit a response body (nor response entity headers such as | |||
| // Content-Length, Content-Type, etc). | |||
| func bodyAllowedForStatus(status int) bool { | |||
| switch { | |||
| case status >= 100 && status <= 199: | |||
| return false | |||
| case status == 204: | |||
| return false | |||
| case status == 304: | |||
| return false | |||
| } | |||
| return true | |||
| } | |||
| func (c *context) Write(b []byte) (int, error) { | |||
| if c.outCode == 0 { | |||
| c.WriteHeader(http.StatusOK) | |||
| } | |||
| if len(b) > 0 && !bodyAllowedForStatus(c.outCode) { | |||
| return 0, http.ErrBodyNotAllowed | |||
| } | |||
| c.outBody = append(c.outBody, b...) | |||
| return len(b), nil | |||
| } | |||
| func (c *context) WriteHeader(code int) { | |||
| if c.outCode != 0 { | |||
| logf(c, 3, "WriteHeader called multiple times on request.") // error level | |||
| return | |||
| } | |||
| c.outCode = code | |||
| } | |||
| func (c *context) post(body []byte, timeout time.Duration) (b []byte, err error) { | |||
| hreq := &http.Request{ | |||
| Method: "POST", | |||
| URL: c.apiURL, | |||
| Header: http.Header{ | |||
| apiEndpointHeader: apiEndpointHeaderValue, | |||
| apiMethodHeader: apiMethodHeaderValue, | |||
| apiContentType: apiContentTypeValue, | |||
| apiDeadlineHeader: []string{strconv.FormatFloat(timeout.Seconds(), 'f', -1, 64)}, | |||
| }, | |||
| Body: ioutil.NopCloser(bytes.NewReader(body)), | |||
| ContentLength: int64(len(body)), | |||
| Host: c.apiURL.Host, | |||
| } | |||
| if info := c.req.Header.Get(dapperHeader); info != "" { | |||
| hreq.Header.Set(dapperHeader, info) | |||
| } | |||
| if info := c.req.Header.Get(traceHeader); info != "" { | |||
| hreq.Header.Set(traceHeader, info) | |||
| } | |||
| tr := apiHTTPClient.Transport.(*http.Transport) | |||
| var timedOut int32 // atomic; set to 1 if timed out | |||
| t := time.AfterFunc(timeout, func() { | |||
| atomic.StoreInt32(&timedOut, 1) | |||
| tr.CancelRequest(hreq) | |||
| }) | |||
| defer t.Stop() | |||
| defer func() { | |||
| // Check if timeout was exceeded. | |||
| if atomic.LoadInt32(&timedOut) != 0 { | |||
| err = errTimeout | |||
| } | |||
| }() | |||
| hresp, err := apiHTTPClient.Do(hreq) | |||
| if err != nil { | |||
| return nil, &CallError{ | |||
| Detail: fmt.Sprintf("service bridge HTTP failed: %v", err), | |||
| Code: int32(remotepb.RpcError_UNKNOWN), | |||
| } | |||
| } | |||
| defer hresp.Body.Close() | |||
| hrespBody, err := ioutil.ReadAll(hresp.Body) | |||
| if hresp.StatusCode != 200 { | |||
| return nil, &CallError{ | |||
| Detail: fmt.Sprintf("service bridge returned HTTP %d (%q)", hresp.StatusCode, hrespBody), | |||
| Code: int32(remotepb.RpcError_UNKNOWN), | |||
| } | |||
| } | |||
| if err != nil { | |||
| return nil, &CallError{ | |||
| Detail: fmt.Sprintf("service bridge response bad: %v", err), | |||
| Code: int32(remotepb.RpcError_UNKNOWN), | |||
| } | |||
| } | |||
| return hrespBody, nil | |||
| } | |||
| func Call(ctx netcontext.Context, service, method string, in, out proto.Message) error { | |||
| if ns := NamespaceFromContext(ctx); ns != "" { | |||
| if fn, ok := NamespaceMods[service]; ok { | |||
| fn(in, ns) | |||
| } | |||
| } | |||
| if f, ctx, ok := callOverrideFromContext(ctx); ok { | |||
| return f(ctx, service, method, in, out) | |||
| } | |||
| // Handle already-done contexts quickly. | |||
| select { | |||
| case <-ctx.Done(): | |||
| return ctx.Err() | |||
| default: | |||
| } | |||
| c := fromContext(ctx) | |||
| if c == nil { | |||
| // Give a good error message rather than a panic lower down. | |||
| return errNotAppEngineContext | |||
| } | |||
| // Apply transaction modifications if we're in a transaction. | |||
| if t := transactionFromContext(ctx); t != nil { | |||
| if t.finished { | |||
| return errors.New("transaction context has expired") | |||
| } | |||
| applyTransaction(in, &t.transaction) | |||
| } | |||
| // Default RPC timeout is 60s. | |||
| timeout := 60 * time.Second | |||
| if deadline, ok := ctx.Deadline(); ok { | |||
| timeout = deadline.Sub(time.Now()) | |||
| } | |||
| data, err := proto.Marshal(in) | |||
| if err != nil { | |||
| return err | |||
| } | |||
| ticket := c.req.Header.Get(ticketHeader) | |||
| // Use a test ticket under test environment. | |||
| if ticket == "" { | |||
| if appid := ctx.Value(&appIDOverrideKey); appid != nil { | |||
| ticket = appid.(string) + defaultTicketSuffix | |||
| } | |||
| } | |||
| // Fall back to use background ticket when the request ticket is not available in Flex or dev_appserver. | |||
| if ticket == "" { | |||
| ticket = DefaultTicket() | |||
| } | |||
| req := &remotepb.Request{ | |||
| ServiceName: &service, | |||
| Method: &method, | |||
| Request: data, | |||
| RequestId: &ticket, | |||
| } | |||
| hreqBody, err := proto.Marshal(req) | |||
| if err != nil { | |||
| return err | |||
| } | |||
| hrespBody, err := c.post(hreqBody, timeout) | |||
| if err != nil { | |||
| return err | |||
| } | |||
| res := &remotepb.Response{} | |||
| if err := proto.Unmarshal(hrespBody, res); err != nil { | |||
| return err | |||
| } | |||
| if res.RpcError != nil { | |||
| ce := &CallError{ | |||
| Detail: res.RpcError.GetDetail(), | |||
| Code: *res.RpcError.Code, | |||
| } | |||
| switch remotepb.RpcError_ErrorCode(ce.Code) { | |||
| case remotepb.RpcError_CANCELLED, remotepb.RpcError_DEADLINE_EXCEEDED: | |||
| ce.Timeout = true | |||
| } | |||
| return ce | |||
| } | |||
| if res.ApplicationError != nil { | |||
| return &APIError{ | |||
| Service: *req.ServiceName, | |||
| Detail: res.ApplicationError.GetDetail(), | |||
| Code: *res.ApplicationError.Code, | |||
| } | |||
| } | |||
| if res.Exception != nil || res.JavaException != nil { | |||
| // This shouldn't happen, but let's be defensive. | |||
| return &CallError{ | |||
| Detail: "service bridge returned exception", | |||
| Code: int32(remotepb.RpcError_UNKNOWN), | |||
| } | |||
| } | |||
| return proto.Unmarshal(res.Response, out) | |||
| } | |||
| func (c *context) Request() *http.Request { | |||
| return c.req | |||
| } | |||
| func (c *context) addLogLine(ll *logpb.UserAppLogLine) { | |||
| // Truncate long log lines. | |||
| // TODO(dsymonds): Check if this is still necessary. | |||
| const lim = 8 << 10 | |||
| if len(*ll.Message) > lim { | |||
| suffix := fmt.Sprintf("...(length %d)", len(*ll.Message)) | |||
| ll.Message = proto.String((*ll.Message)[:lim-len(suffix)] + suffix) | |||
| } | |||
| c.pendingLogs.Lock() | |||
| c.pendingLogs.lines = append(c.pendingLogs.lines, ll) | |||
| c.pendingLogs.Unlock() | |||
| } | |||
| var logLevelName = map[int64]string{ | |||
| 0: "DEBUG", | |||
| 1: "INFO", | |||
| 2: "WARNING", | |||
| 3: "ERROR", | |||
| 4: "CRITICAL", | |||
| } | |||
| func logf(c *context, level int64, format string, args ...interface{}) { | |||
| if c == nil { | |||
| panic("not an App Engine context") | |||
| } | |||
| s := fmt.Sprintf(format, args...) | |||
| s = strings.TrimRight(s, "\n") // Remove any trailing newline characters. | |||
| c.addLogLine(&logpb.UserAppLogLine{ | |||
| TimestampUsec: proto.Int64(time.Now().UnixNano() / 1e3), | |||
| Level: &level, | |||
| Message: &s, | |||
| }) | |||
| log.Print(logLevelName[level] + ": " + s) | |||
| } | |||
| // flushLog attempts to flush any pending logs to the appserver. | |||
| // It should not be called concurrently. | |||
| func (c *context) flushLog(force bool) (flushed bool) { | |||
| c.pendingLogs.Lock() | |||
| // Grab up to 30 MB. We can get away with up to 32 MB, but let's be cautious. | |||
| n, rem := 0, 30<<20 | |||
| for ; n < len(c.pendingLogs.lines); n++ { | |||
| ll := c.pendingLogs.lines[n] | |||
| // Each log line will require about 3 bytes of overhead. | |||
| nb := proto.Size(ll) + 3 | |||
| if nb > rem { | |||
| break | |||
| } | |||
| rem -= nb | |||
| } | |||
| lines := c.pendingLogs.lines[:n] | |||
| c.pendingLogs.lines = c.pendingLogs.lines[n:] | |||
| c.pendingLogs.Unlock() | |||
| if len(lines) == 0 && !force { | |||
| // Nothing to flush. | |||
| return false | |||
| } | |||
| rescueLogs := false | |||
| defer func() { | |||
| if rescueLogs { | |||
| c.pendingLogs.Lock() | |||
| c.pendingLogs.lines = append(lines, c.pendingLogs.lines...) | |||
| c.pendingLogs.Unlock() | |||
| } | |||
| }() | |||
| buf, err := proto.Marshal(&logpb.UserAppLogGroup{ | |||
| LogLine: lines, | |||
| }) | |||
| if err != nil { | |||
| log.Printf("internal.flushLog: marshaling UserAppLogGroup: %v", err) | |||
| rescueLogs = true | |||
| return false | |||
| } | |||
| req := &logpb.FlushRequest{ | |||
| Logs: buf, | |||
| } | |||
| res := &basepb.VoidProto{} | |||
| c.pendingLogs.Lock() | |||
| c.pendingLogs.flushes++ | |||
| c.pendingLogs.Unlock() | |||
| if err := Call(toContext(c), "logservice", "Flush", req, res); err != nil { | |||
| log.Printf("internal.flushLog: Flush RPC: %v", err) | |||
| rescueLogs = true | |||
| return false | |||
| } | |||
| return true | |||
| } | |||
| const ( | |||
| // Log flushing parameters. | |||
| flushInterval = 1 * time.Second | |||
| forceFlushInterval = 60 * time.Second | |||
| ) | |||
| func (c *context) logFlusher(stop <-chan int) { | |||
| lastFlush := time.Now() | |||
| tick := time.NewTicker(flushInterval) | |||
| for { | |||
| select { | |||
| case <-stop: | |||
| // Request finished. | |||
| tick.Stop() | |||
| return | |||
| case <-tick.C: | |||
| force := time.Now().Sub(lastFlush) > forceFlushInterval | |||
| if c.flushLog(force) { | |||
| lastFlush = time.Now() | |||
| } | |||
| } | |||
| } | |||
| } | |||
| func ContextForTesting(req *http.Request) netcontext.Context { | |||
| return toContext(&context{req: req}) | |||
| } | |||
+ 44
- 3
vendor/google.golang.org/appengine/internal/identity.go
View File
+ 4
- 0
vendor/google.golang.org/appengine/internal/identity_classic.go
View File
+ 11
- 0
vendor/google.golang.org/appengine/internal/identity_flex.go
View File
| @ -0,0 +1,11 @@ | |||
| // Copyright 2018 Google LLC. All rights reserved. | |||
| // Use of this source code is governed by the Apache 2.0 | |||
| // license that can be found in the LICENSE file. | |||
| // +build appenginevm | |||
| package internal | |||
| func init() { | |||
| appengineFlex = true | |||
| } | |||
+ 1
- 0
vendor/google.golang.org/appengine/internal/main.go
View File
+ 7
- 0
vendor/google.golang.org/appengine/internal/main_common.go
View File
| @ -0,0 +1,7 @@ | |||
| package internal | |||
| // MainPath stores the file path of the main package. On App Engine Standard | |||
| // using Go version 1.9 and below, this will be unset. On App Engine Flex and | |||
| // App Engine Standard second-gen (Go 1.11 and above), this will be the | |||
| // filepath to package main. | |||
| var MainPath string | |||