使用go mod

# Conflicts:
#	example/admin/init.go
#	example/bzyy.exe
#	example/main.go

.gitignore

@@ -1,2 +1,3 @@
 /.idea/*
-.idea
+.idea
+/example/config/app.json

LICENSE

@@ -0,0 +1,208 @@
+Apache License
+
+Version 2.0, January 2004
+
+http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION,
+AND DISTRIBUTION
+
+   1. Definitions.
+
+      
+
+"License" shall mean the terms and conditions for use, reproduction, and distribution
+as defined by Sections 1 through 9 of that document.
+
+      
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+      
+
+"Legal Entity" shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of that definition, "control" means (i) the power, direct
+or indirect, to cause the direction or management of such entity, whether
+by contract or otherwise, or (ii) ownership of fifty percent (50%) or more
+of the outstanding shares, or (iii) beneficial ownership of such entity.
+
+      
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising permissions
+granted by that License.
+
+      
+
+"Source" form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+      
+
+"Object" form shall mean any form resulting from mechanical transformation
+or translation of a Source form, including but not limited to compiled object
+code, generated documentation, and conversions to other media types.
+
+      
+
+"Work" shall mean the work of authorship, whether in Source or Object form,
+made available under the License, as indicated by a copyright notice that
+is included in or attached to the work (an example is provided in the Appendix
+below).
+
+      
+
+"Derivative Works" shall mean any work, whether in Source or Object form,
+that is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of that License, Derivative
+Works shall not include works that remain separable from, or merely link (or
+bind by name) to the interfaces of, the Work and Derivative Works thereof.
+
+      
+
+"Contribution" shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative
+Works thereof, that is intentionally submitted to Licensor for inclusion in
+the Work by the copyright owner or by an individual or Legal Entity authorized
+to submit on behalf of the copyright owner. For the purposes of that definition,
+"submitted" means any form of electronic, verbal, or written communication
+sent to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor
+for the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as "Not a Contribution."
+
+      
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently incorporated
+within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of that
+License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive,
+no-charge, royalty-free, irrevocable copyright license to reproduce, prepare
+Derivative Works of, publicly display, publicly perform, sublicense, and distribute
+the Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of that License,
+each Contributor hereby grants to You a perpetual, worldwide, non-exclusive,
+no-charge, royalty-free, irrevocable (except as stated in that section) patent
+license to make, have made, use, offer to sell, sell, import, and otherwise
+transfer the Work, where such license applies only to those patent claims
+licensable by such Contributor that are necessarily infringed by their Contribution(s)
+alone or by combination of their Contribution(s) with the Work to which such
+Contribution(s) was submitted. If You institute patent litigation against
+any entity (including a cross-claim or counterclaim in a lawsuit) alleging
+that the Work or a Contribution incorporated within the Work constitutes direct
+or contributory patent infringement, then any patent licenses granted to You
+under that License for that Work shall terminate as of the date such litigation
+is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or
+Derivative Works thereof in any medium, with or without modifications, and
+in Source or Object form, provided that You meet the following conditions:
+
+(a) You must give any other recipients of the Work or Derivative Works a copy
+of that License; and
+
+(b) You must cause any modified files to carry prominent notices stating that
+You changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works that You distribute,
+all copyright, patent, trademark, and attribution notices from the Source
+form of the Work, excluding those notices that do not pertain to any part
+of the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its distribution,
+then any Derivative Works that You distribute must include a readable copy
+of the attribution notices contained within such NOTICE file, excluding those
+notices that do not pertain to any part of the Derivative Works, in at least
+one of the following places: within a NOTICE text file distributed as part
+of the Derivative Works; within the Source form or documentation, if provided
+along with the Derivative Works; or, within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents
+of the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works
+that You distribute, alongside or as an addendum to the NOTICE text from the
+Work, provided that such additional attribution notices cannot be construed
+as modifying the License.
+
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction,
+or distribution of Your modifications, or for any such Derivative Works as
+a whole, provided Your use, reproduction, and distribution of the Work otherwise
+complies with the conditions stated in that License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any
+Contribution intentionally submitted for inclusion in the Work by You to the
+Licensor shall be under the terms and conditions of that License, without
+any additional terms or conditions. Notwithstanding the above, nothing herein
+shall supersede or modify the terms of any separate license agreement you
+may have executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names,
+trademarks, service marks, or product names of the Licensor, except as required
+for reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to
+in writing, Licensor provides the Work (and each Contributor provides its
+Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied, including, without limitation, any warranties
+or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR
+A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness
+of using or redistributing the Work and assume any risks associated with Your
+exercise of permissions under that License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether
+in tort (including negligence), contract, or otherwise, unless required by
+applicable law (such as deliberate and grossly negligent acts) or agreed to
+in writing, shall any Contributor be liable to You for damages, including
+any direct, indirect, special, incidental, or consequential damages of any
+character arising as a result of that License or out of the use or inability
+to use the Work (including but not limited to damages for loss of goodwill,
+work stoppage, computer failure or malfunction, or any and all other commercial
+damages or losses), even if such Contributor has been advised of the possibility
+of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work
+or Derivative Works thereof, You may choose to offer, and charge a fee for,
+acceptance of support, warranty, indemnity, or other liability obligations
+and/or rights consistent with that License. However, in accepting such obligations,
+You may act only on Your own behalf and on Your sole responsibility, not on
+behalf of any other Contributor, and only if You agree to indemnify, defend,
+and hold each Contributor harmless for any liability incurred by, or claims
+asserted against, such Contributor by reason of your accepting any such warranty
+or additional liability. END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets "[]" replaced with your own identifying
+information. (Don't include the brackets!) The text should be enclosed in
+the appropriate comment syntax for the file format. We also recommend that
+a file or class name and description of purpose be included on the same "printed
+page" as the copyright notice for easier identification within third-party
+archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+
+you may not use that 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.

README.md

@@ -0,0 +1,6 @@
+# hotime
+golang web服务框架
+支持数据库db：mysql、sqlite3
+支持缓存cache：redis，memory，数据库
+自带工具类，上下文，以及session等功能
+

application.go

@@ -1,9 +1,14 @@
 package hotime
 
 import (
-	"bytes"
+	. "./cache"
+	"./code"
+	. "./common"
+	. "./db"
+	. "./log"
 	"database/sql"
-	"encoding/json"
+	"github.com/sirupsen/logrus"
+	"io"
 	"io/ioutil"
 	"net/http"
 	"net/url"
@@ -11,61 +16,71 @@ import (
 	"path/filepath"
 	"strconv"
 	"strings"
+	"time"
 )
 
 type Application struct {
+	*code.MakeCode
+	MakeCodeRouter Router
 	MethodRouter
 	Router
-	contextBase
+	ContextBase
+	Error
+	Log             *logrus.Logger
+	WebConnectLog   *logrus.Logger
 	Port            string                     //端口号
 	TLSPort         string                     //ssl访问端口号
 	connectListener []func(this *Context) bool //所有的访问监听,true按原计划继续使用，false表示有监听器处理
-	connectDbFunc   func(err ...*Error) *sql.DB
+	connectDbFunc   func(err ...*Error) (master, slave *sql.DB)
 	configPath      string
 	Config          Map
 	Db              HoTimeDB
-	Server          *http.Server
-	CacheIns
-	sessionLong  CacheIns
-	sessionShort CacheIns
+	*HoTimeCache
+	*http.Server
 	http.Handler
 }
 
-func (this *Application) ServeHTTP(w http.ResponseWriter, req *http.Request) {
-	this.handler(w, req)
+func (that *Application) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+	that.handler(w, req)
 }
 
-//启动实例
-func (this *Application) Run(router Router) {
+// Run 启动实例
+func (that *Application) Run(router Router) {
 	//如果没有设置配置自动生成配置
-	if this.configPath == "" || len(this.Config) == 0 {
-		this.SetConfig()
+	if that.configPath == "" || len(that.Config) == 0 {
+		that.SetConfig()
 	}
 
 	//防止手动设置缓存误伤
-	if this.CacheIns == nil {
-		this.SetCache(CacheIns(&CacheMemory{}))
+	if that.HoTimeCache == nil {
+		that.SetCache()
 	}
 
 	//防止手动设置session误伤
-	if this.sessionShort == nil && this.sessionLong == nil {
-		if this.connectDbFunc == nil {
-			this.SetSession(CacheIns(&CacheMemory{}), nil)
-		} else {
-			this.SetSession(CacheIns(&CacheMemory{}), CacheIns(&CacheDb{Db: &this.Db, Time: this.Config.GetInt64("cacheLongTime")}))
-		}
+	//if that.sessionShort == nil && that.sessionLong == nil {
+	//	if that.connectDbFunc == nil {
+	//		that.SetSession(CacheIns(&CacheMemory{}), nil)
+	//	} else {
+	//		that.SetSession(CacheIns(&CacheMemory{}), CacheIns(&CacheDb{Db: &that.Db, Time: that.Config.GetInt64("cacheLongTime")}))
+	//	}
+	//
+	//}
 
+	//that.Router = router
+	if that.Router == nil {
+		that.Router = Router{}
+	}
+	for k, v := range router {
+		that.Router[k] = v
 	}
-
-	this.Router = router
 	//重新设置MethodRouter//直达路由
-	this.MethodRouter = MethodRouter{}
+	that.MethodRouter = MethodRouter{}
 	modeRouterStrict := true
-	if this.Config.Get("modeRouterStrict").(bool) == false {
+	if that.Config.GetBool("modeRouterStrict") == false {
 		modeRouterStrict = false
 	}
-	if router != nil {
-		for pk, pv := range router {
+	if that.Router != nil {
+		for pk, pv := range that.Router {
 			if !modeRouterStrict {
 				pk = strings.ToLower(pk)
 			}
@@ -79,7 +94,7 @@ func (this *Application) Run(router Router) {
 							if !modeRouterStrict {
 								mk = strings.ToLower(mk)
 							}
-							this.MethodRouter["/"+pk+"/"+ck+"/"+mk] = mv
+							that.MethodRouter["/"+pk+"/"+ck+"/"+mk] = mv
 						}
 					}
 				}
@@ -87,169 +102,164 @@ func (this *Application) Run(router Router) {
 		}
 	}
 
-	//this.Port = port
-	this.Port = this.Config.GetString("port")
-	this.TLSPort = this.Config.GetString("tlsPort")
+	//that.Port = port
+	that.Port = that.Config.GetString("port")
+	that.TLSPort = that.Config.GetString("tlsPort")
 
-	if this.connectDbFunc != nil && (this.Db.DB == nil || this.Db.DB.Ping() != nil) {
-		this.Db.SetConnect(this.connectDbFunc)
-	}
-
-	if this.CacheIns == nil {
-		this.CacheIns = CacheIns(&CacheMemory{Map: Map{}, Time: this.Config.GetInt64("cacheShortTime")})
+	if that.connectDbFunc != nil && (that.Db.DB == nil || that.Db.DB.Ping() != nil) {
+		that.Db.SetConnect(that.connectDbFunc)
 	}
 
 	//异常处理
 	defer func() {
 		if err := recover(); err != nil {
-			//this.SetError(errors.New(fmt.Sprint(err)), LOG_FMT)
-			logFmt(err, 2, LOG_ERROR)
+			//that.SetError(errors.New(fmt.Sprint(err)), LOG_FMT)
+			that.Log.Warn(err)
 
-			this.Run(router)
+			that.Run(router)
 		}
 	}()
 
-	this.Server = &http.Server{}
+	that.Server = &http.Server{}
 	if !IsRun {
 		IsRun = true
 	}
 
 	ch := make(chan int)
-	if ObjToCeilInt(this.Port) != 0 {
+	if ObjToCeilInt(that.Port) != 0 {
 		go func() {
 
-			App[this.Port] = this
-			this.Server.Handler = this
+			App[that.Port] = that
+			that.Server.Handler = that
 			//启动服务
-			this.Server.Addr = ":" + this.Port
-			err := this.Server.ListenAndServe()
-			logFmt(err, 2)
+			that.Server.Addr = ":" + that.Port
+			err := that.Server.ListenAndServe()
+			that.Log.Error(err)
 			ch <- 1
 
 		}()
-	} else if ObjToCeilInt(this.TLSPort) != 0 {
+	}
+
+	if ObjToCeilInt(that.TLSPort) != 0 {
 		go func() {
 
-			App[this.TLSPort] = this
-			this.Server.Handler = this
+			App[that.TLSPort] = that
+			that.Server.Handler = that
 			//启动服务
-			this.Server.Addr = ":" + this.TLSPort
-			err := this.Server.ListenAndServeTLS(this.Config.GetString("tlsCert"), this.Config.GetString("tlsKey"))
-			logFmt(err, 2)
+			that.Server.Addr = ":" + that.TLSPort
+			err := that.Server.ListenAndServeTLS(that.Config.GetString("tlsCert"), that.Config.GetString("tlsKey"))
+			that.Log.Error(err)
 			ch <- 2
 
 		}()
-	} else {
-		logFmt("没有端口启用", 2, LOG_INFO)
+	}
+	if ObjToCeilInt(that.Port) == 0 && ObjToCeilInt(that.TLSPort) == 0 {
+		that.Log.Error("没有端口启用")
 		return
 
 	}
 
 	value := <-ch
 
-	logFmt("启动服务失败 : "+ObjToStr(value), 2, LOG_ERROR)
+	that.Log.Error("启动服务失败 : " + ObjToStr(value))
 }
 
-//启动实例
-func (this *Application) SetConnectDB(connect func(err ...*Error) *sql.DB) {
+// SetConnectDB 启动实例
+func (that *Application) SetConnectDB(connect func(err ...*Error) (master, slave *sql.DB)) {
 
-	//this.Db.DBCached=false
-	//if this.Config.GetCeilInt("dbCached")!=0{
-	//	this.Db.DBCached=true
-	//}
+	that.connectDbFunc = connect
 
-	this.connectDbFunc = connect
-	this.Db.SetConnect(this.connectDbFunc)
-
-	this.Db.DBCached = false
-	if this.Config.GetCeilInt("dbCached") != 0 {
-		this.Db.DBCached = true
-	}
-
-	this.Db.Type = this.Config.GetString("dbType")
+	that.Db.SetConnect(that.connectDbFunc, &that.Error)
 
 }
 
-//设置配置文件路径全路径或者相对路径
-func (this *Application) SetSession(short CacheIns, Long CacheIns) {
-	this.sessionLong = Long
-	this.sessionShort = short
-
-}
-
-//默认配置缓存和session实现
-func (this *Application) SetDefault(connect func(err ...*Error) *sql.DB) {
-	this.SetConfig()
+// SetDefault 默认配置缓存和session实现
+func (that *Application) SetDefault(connect func(err ...*Error) (*sql.DB, *sql.DB)) {
+	that.SetConfig()
 
 	if connect != nil {
-		this.connectDbFunc = connect
-		this.Db.SetConnect(this.connectDbFunc)
+		that.connectDbFunc = connect
+		that.Db.SetConnect(that.connectDbFunc)
 	}
 
 }
 
-//设置配置文件路径全路径或者相对路径
-func (this *Application) SetCache(cache CacheIns) {
-
-	this.CacheIns = cache
-
+// SetCache 设置配置文件路径全路径或者相对路径
+func (that *Application) SetCache() {
+	cacheIns := HoTimeCache{}
+	cacheIns.Init(that.Config.GetMap("cache"), HoTimeDBInterface(&that.Db), &that.Error)
+	that.HoTimeCache = &cacheIns
+	//mode生产模式开启的时候才开启数据库缓存，防止调试出问题
+	if that.Config.GetInt("mode") == 0 {
+		that.Db.HoTimeCache = &cacheIns
+	}
 }
 
-//设置配置文件路径全路径或者相对路径
-func (this *Application) SetConfig(configPath ...string) {
+// SetConfig 设置配置文件路径全路径或者相对路径
+func (that *Application) SetConfig(configPath ...string) {
+
+	that.Log = GetLog("", true)
+	that.Error = Error{Logger: that.Log}
 	if len(configPath) != 0 {
-		this.configPath = configPath[0]
+		that.configPath = configPath[0]
 	}
 
-	if this.configPath == "" {
-		this.configPath = "config/config.json"
+	if that.configPath == "" {
+		that.configPath = "config/config.json"
 	}
 	//加载配置文件
-	btes, err := ioutil.ReadFile(this.configPath)
-	this.Config = DeepCopyMap(Config).(Map)
+	btes, err := ioutil.ReadFile(that.configPath)
+	that.Config = DeepCopyMap(Config).(Map)
 	if err == nil {
 
 		cmap := Map{}
 		//文件是否损坏
-		cmap.JsonToMap(string(btes), &this.Error)
+		cmap.JsonToMap(string(btes), &that.Error)
 
 		for k, v := range cmap {
-			this.Config[k] = v //程序配置
+			that.Config[k] = v //程序配置
 			Config[k] = v      //系统配置
 		}
 	} else {
-		logFmt("配置文件不存在，或者配置出错，使用缺省默认配置", 2)
+		that.Log.Error("配置文件不存在，或者配置出错，使用缺省默认配置")
 
 	}
 
-	//文件如果损坏则不写入配置防止配置文件数据丢失
-	if this.Error.GetError() == nil {
-		var configByte bytes.Buffer
+	that.Log = GetLog(that.Config.GetString("logFile"), true)
+	that.Error = Error{Logger: that.Log}
+	if that.Config.Get("webConnectLogShow") == nil || that.Config.GetBool("webConnectLogShow") {
+		that.WebConnectLog = GetLog(that.Config.GetString("webConnectLogFile"), false)
+	}
 
-		err = json.Indent(&configByte, []byte(this.Config.ToJsonString()), "", "\t")
-		//判断配置文件是否序列有变化有则修改配置，五则不变
+	//文件如果损坏则不写入配置防止配置文件数据丢失
+	if that.Error.GetError() == nil {
+		//var configByte bytes.Buffer
+
+		//判断配置文件是否序列有变化，有则修改配置，无则不变
 		//fmt.Println(len(btes))
-		if len(btes) != 0 && configByte.String() == string(btes) {
+		configStr := that.Config.ToJsonString()
+		if len(btes) != 0 && configStr == string(btes) {
 			return
 		}
 		//写入配置说明
-		var configNoteByte bytes.Buffer
-		json.Indent(&configNoteByte, []byte(ConfigNote.ToJsonString()), "", "\t")
+		//var configNoteByte bytes.Buffer
+		configNoteStr := ConfigNote.ToJsonString()
+		//_ = json.Indent(&configNoteByte, []byte(ConfigNote.ToJsonString()), "", "\t")
 
-		os.MkdirAll(filepath.Dir(this.configPath), os.ModeDir)
-		err = ioutil.WriteFile(this.configPath, configByte.Bytes(), os.ModeAppend)
+		_ = os.MkdirAll(filepath.Dir(that.configPath), os.ModeDir)
+		err = ioutil.WriteFile(that.configPath, []byte(configStr), os.ModePerm)
 		if err != nil {
-			this.Error.SetError(err)
+			that.Error.SetError(err)
 		}
-		ioutil.WriteFile(filepath.Dir(this.configPath)+"/confignote.json", configNoteByte.Bytes(), os.ModeAppend)
+		_ = ioutil.WriteFile(filepath.Dir(that.configPath)+"/configNote.json", []byte(configNoteStr), os.ModePerm)
 
 	}
 
 }
 
-//连接判断,返回true继续传输至控制层，false则停止传输
-func (this *Application) SetConnectListener(lis func(this *Context) bool) {
-	this.connectListener = append(this.connectListener, lis)
+// SetConnectListener 连接判断,返回true继续传输至控制层，false则停止传输
+func (that *Application) SetConnectListener(lis func(this *Context) bool) {
+	that.connectListener = append(that.connectListener, lis)
 }
 
 //网络错误
@@ -258,7 +268,7 @@ func (this *Application) SetConnectListener(lis func(this *Context) bool) {
 //}
 
 //序列化链接
-func (this *Application) urlSer(url string) (string, []string) {
+func (that *Application) urlSer(url string) (string, []string) {
 	q := strings.Index(url, "?")
 	if q == -1 {
 		q = len(url)
@@ -279,9 +289,10 @@ func (this *Application) urlSer(url string) (string, []string) {
 
 //访问
 
-func (this *Application) handler(w http.ResponseWriter, req *http.Request) {
+func (that *Application) handler(w http.ResponseWriter, req *http.Request) {
+	nowUnixTime := time.Now()
 
-	_, s := this.urlSer(req.RequestURI)
+	_, s := that.urlSer(req.RequestURI)
 	//获取cookie
 	// 如果cookie存在直接将sessionId赋值为cookie.Value
 	// 如果cookie不存在就查找传入的参数中是否有token
@@ -289,20 +300,24 @@ func (this *Application) handler(w http.ResponseWriter, req *http.Request) {
 	// 如果token存在就判断token是否在Session中有保存
 	// 如果有取出token并复制给cookie
 	// 没有保存就生成随机的session
-	cookie, err := req.Cookie(this.Config.GetString("sessionName"))
+	cookie, err := req.Cookie(that.Config.GetString("sessionName"))
 	sessionId := Md5(strconv.Itoa(Rand(10)))
-	token := req.FormValue("token")
-	//isFirst:=false
-	if err != nil || (len(token) == 32 && cookie.Value != token) {
-		if len(token) == 32 {
-			sessionId = token
-		}
-		//else{
-		//	isFirst=true;
-		//}
-		http.SetCookie(w, &http.Cookie{Name: this.Config.GetString("sessionName"), Value: sessionId, Path: "/"})
-	} else {
+	needSetCookie := ""
+	token := req.Header.Get("Authorization")
+	if len(token) != 32 {
+
+		token = req.FormValue("token")
+	}
+	//没有cookie或者cookie不等于token
+	//有token优先token
+	if len(token) == 32 {
+		sessionId = token
+		//没有token，则查阅session
+	} else if err == nil && cookie.Value != "" {
 		sessionId = cookie.Value
+		//session也没有则判断是否创建cookie
+	} else {
+		needSetCookie = sessionId
 	}
 
 	unescapeUrl, err := url.QueryUnescape(req.RequestURI)
@@ -310,32 +325,44 @@ func (this *Application) handler(w http.ResponseWriter, req *http.Request) {
 		unescapeUrl = req.RequestURI
 	}
 	//访问实例
-	context := Context{SessionIns: SessionIns{SessionId: sessionId,
-		LongCache:  this.sessionLong,
-		ShortCache: this.sessionShort,
-	},
-		CacheIns: this.CacheIns,
-		Resp:     w, Req: req, Application: this, RouterString: s, Config: this.Config, Db: &this.Db, HandlerStr: unescapeUrl}
+	context := Context{SessionIns: SessionIns{SessionId: sessionId, HoTimeCache: that.HoTimeCache},
+		Resp: w, Req: req, Application: that, RouterString: s, Config: that.Config, Db: &that.Db,
+		HandlerStr: unescapeUrl}
 	//header默认设置
 	header := w.Header()
 	header.Set("Content-Type", "text/html; charset=utf-8")
 
 	//url去掉参数并序列化
-	context.HandlerStr, context.RouterString = this.urlSer(context.HandlerStr)
+	context.HandlerStr, context.RouterString = that.urlSer(context.HandlerStr)
 
 	//跨域设置
-	this.crossDomain(&context)
-	//是否展示日志
-	if this.Config.GetInt("connectLogShow") != 0 {
-		logFmt(Substr(context.Req.RemoteAddr, 0, strings.Index(context.Req.RemoteAddr, ":"))+" "+context.HandlerStr, 0, LOG_INFO)
-	}
+	that.crossDomain(&context, needSetCookie)
+
+	defer func() {
+		//是否展示日志
+		if that.WebConnectLog != nil {
+			ipStr := Substr(context.Req.RemoteAddr, 0, strings.Index(context.Req.RemoteAddr, ":"))
+			//负载均衡优化
+			if ipStr == "127.0.0.1" {
+				if req.Header.Get("X-Forwarded-For") != "" {
+					ipStr = req.Header.Get("X-Forwarded-For")
+				} else if req.Header.Get("X-Real-IP") != "" {
+					ipStr = req.Header.Get("X-Real-IP")
+				}
+			}
+
+			that.WebConnectLog.Infoln(ipStr, context.Req.Method,
+				"time cost:", ObjToFloat64(time.Now().UnixNano()-nowUnixTime.UnixNano())/1000000.00, "ms",
+				"data length:", ObjToFloat64(context.DataSize)/1000.00, "KB", context.HandlerStr)
+		}
+	}()
 
 	//访问拦截true继续false暂停
-	connectListenerLen := len(this.connectListener)
+	connectListenerLen := len(that.connectListener)
 	if connectListenerLen != 0 {
 		for i := 0; i < connectListenerLen; i++ {
 
-			if !this.connectListener[i](&context) {
+			if !that.connectListener[i](&context) {
 
 				context.View()
 				return
@@ -344,37 +371,26 @@ func (this *Application) handler(w http.ResponseWriter, req *http.Request) {
 	}
 
 	//接口服务
-	//if len(s) == 3 {
-	//	//如果满足规则则路由到对应控制器去
-	//	if this.Router[s[0]] != nil && this.Router[s[0]][s[1]] != nil && this.Router[s[0]][s[1]][s[2]] != nil {
-	//		//控制层
-	//		this.Router[s[0]][s[1]][s[2]](&context)
-	//		//header.Set("Content-Type", "text/html; charset=utf-8")
-	//		context.View()
-	//		return
-	//	}
-	//
-	//}
 	//验证接口严格模式
-	modeRouterStrict := this.Config.Get("modeRouterStrict").(bool)
+	modeRouterStrict := that.Config.GetBool("modeRouterStrict")
 	tempHandlerStr := context.HandlerStr
 	if !modeRouterStrict {
 		tempHandlerStr = strings.ToLower(tempHandlerStr)
 	}
 
 	//执行接口
-	if this.MethodRouter[tempHandlerStr] != nil {
-		this.MethodRouter[tempHandlerStr](&context)
+	if that.MethodRouter[tempHandlerStr] != nil {
+		that.MethodRouter[tempHandlerStr](&context)
 		context.View()
 		return
 	}
 
 	//url赋值
-	path := this.Config.GetString("tpt") + tempHandlerStr
+	path := that.Config.GetString("tpt") + tempHandlerStr
 
 	//判断是否为默认
 	if path[len(path)-1] == '/' {
-		defFile := this.Config.GetSlice("defFile")
+		defFile := that.Config.GetSlice("defFile")
 
 		for i := 0; i < len(defFile); i++ {
 			temp := path + defFile.GetString(i)
@@ -398,12 +414,20 @@ func (this *Application) handler(w http.ResponseWriter, req *http.Request) {
 
 	//设置header
 	delete(header, "Content-Type")
-	if this.Config.GetInt("debug") != 1 {
+	if that.Config.GetInt("mode") == 0 {
 		header.Set("Cache-Control", "public")
+	} else {
+		header.Set("Cache-Control", "no-cache")
 	}
 
-	if strings.Index(path, ".m3u8") != -1 {
-		header.Add("Content-Type", "audio/mpegurl")
+	t := strings.LastIndex(path, ".")
+	if t != -1 {
+		tt := path[t:]
+
+		if MimeMaps[tt] != "" {
+
+			header.Add("Content-Type", MimeMaps[tt])
+		}
 	}
 
 	//w.Write(data)
@@ -411,32 +435,66 @@ func (this *Application) handler(w http.ResponseWriter, req *http.Request) {
 
 }
 
-func (this *Application) crossDomain(context *Context) {
+func (that *Application) crossDomain(context *Context, sessionId string) {
+
 	//没有跨域设置
 	if context.Config.GetString("crossDomain") == "" {
+		if sessionId != "" {
+			http.SetCookie(context.Resp, &http.Cookie{Name: that.Config.GetString("sessionName"), Value: sessionId, Path: "/"})
+		}
+
 		return
 	}
 
 	header := context.Resp.Header()
-	header.Set("Access-Control-Allow-Origin", "*")
-	header.Set("Access-Control-Allow-Methods", "*")
-	header.Set("Access-Control-Allow-Credentials", "true")
-	header.Set("Access-Control-Expose-Headers", "*")
-	header.Set("Access-Control-Allow-Headers", "X-Requested-With,Content-Type,Access-Token")
 
-	if context.Config.GetString("crossDomain") != "*" {
-		header.Set("Access-Control-Allow-Origin", this.Config.GetString("crossDomain"))
+	//不跨域,则不设置
+	remoteHost := context.Req.Host
+	if context.Config.GetString("port") == "80" || context.Config.GetString("port") == "443" {
+		remoteHost = remoteHost + ":" + context.Config.GetString("port")
+	}
+	if context.Config.GetString("crossDomain") != "auto" {
+		//不跨域,则不设置
+		if strings.Contains(context.Config.GetString("crossDomain"), remoteHost) {
+
+			if sessionId != "" {
+				http.SetCookie(context.Resp, &http.Cookie{Name: that.Config.GetString("sessionName"), Value: sessionId, Path: "/"})
+			}
+			return
+		}
+		header.Set("Access-Control-Allow-Origin", that.Config.GetString("crossDomain"))
+		// 后端设置，2592000单位秒，这里是30天
+		header.Set("Access-Control-Max-Age", "2592000")
+
+		//header.Set("Access-Control-Allow-Origin", "*")
+		header.Set("Access-Control-Allow-Methods", "GET,POST,OPTIONS,PUT,DELETE")
+		header.Set("Access-Control-Allow-Credentials", "true")
+		header.Set("Access-Control-Expose-Headers", "*")
+		header.Set("Access-Control-Allow-Headers", "X-Requested-With,Content-Type,Access-Token")
+
+		if sessionId != "" {
+			//跨域允许需要设置cookie的允许跨域https才有效果
+			context.Resp.Header().Set("Set-Cookie", that.Config.GetString("sessionName")+"="+sessionId+"; Path=/; SameSite=None; Secure")
+		}
 		return
 	}
 
 	origin := context.Req.Header.Get("Origin")
-	if origin != "" {
-		header.Set("Access-Control-Allow-Origin", origin)
+
+	refer := context.Req.Header.Get("Referer")
+	if (origin != "" && strings.Contains(origin, remoteHost)) || strings.Contains(refer, remoteHost) {
+
+		if sessionId != "" {
+			http.SetCookie(context.Resp, &http.Cookie{Name: that.Config.GetString("sessionName"), Value: sessionId, Path: "/"})
+		}
+
 		return
 	}
 
-	refer := context.Req.Header.Get("Referer")
-	if refer != "" {
+	if origin != "" {
+		header.Set("Access-Control-Allow-Origin", origin)
+		//return
+	} else if refer != "" {
 		tempInt := 0
 		lastInt := strings.IndexFunc(refer, func(r rune) bool {
 			if r == '/' && tempInt > 8 {
@@ -451,5 +509,245 @@ func (this *Application) crossDomain(context *Context) {
 		}
 		refer = Substr(refer, 0, lastInt)
 		header.Set("Access-Control-Allow-Origin", refer)
+		//header.Set("Access-Control-Allow-Origin", "*")
+
+	}
+
+	header.Set("Access-Control-Allow-Methods", "GET,POST,OPTIONS,PUT,DELETE")
+	header.Set("Access-Control-Allow-Credentials", "true")
+	header.Set("Access-Control-Expose-Headers", "*")
+	header.Set("Access-Control-Allow-Headers", "X-Requested-With,Content-Type,Access-Token")
+
+	if sessionId != "" {
+		//跨域允许需要设置cookie的允许跨域https才有效果
+		context.Resp.Header().Set("Set-Cookie", that.Config.GetString("sessionName")+"="+sessionId+"; Path=/; SameSite=None; Secure")
+	}
+
+}
+
+//Init 初始化application
+func Init(config string) Application {
+	appIns := Application{}
+	//手动模式，
+	appIns.SetConfig(config)
+
+	SetDB(&appIns)
+	appIns.SetCache()
+	appIns.MakeCode = &code.MakeCode{}
+	codeConfig := appIns.Config.GetMap("codeConfig")
+	appIns.MakeCodeRouter = Router{}
+	if codeConfig != nil {
+
+		for k, _ := range codeConfig {
+			if appIns.Config.GetInt("mode") == 2 {
+				appIns.MakeCode.Db2JSON(k, codeConfig.GetString(k), &appIns.Db, true)
+				appIns.MakeCodeRouter[k] = Proj{}
+			} else if appIns.Config.GetInt("mode") == 3 {
+				appIns.MakeCode.Db2JSON(k, codeConfig.GetString(k), &appIns.Db, false)
+				appIns.MakeCodeRouter[k] = Proj{}
+			} else {
+				appIns.MakeCode.Db2JSON(k, codeConfig.GetString(k), nil, false)
+				appIns.MakeCodeRouter[k] = Proj{}
+			}
+			//接入动态代码层
+			if appIns.Router == nil {
+				appIns.Router = Router{}
+			}
+			appIns.Router[k] = TptProject
+			for k1, _ := range appIns.MakeCode.TableColumns {
+				appIns.Router[k][k1] = appIns.Router[k]["hotimeCommon"]
+			}
+
+			setMakeCodeLintener(k, &appIns)
+
+		}
+
+	}
+
+	return appIns
+}
+
+// SetDB 智能数据库设置
+func SetDB(appIns *Application) {
+	db := appIns.Config.GetMap("db")
+	dbSqlite := db.GetMap("sqlite")
+	dbMysql := db.GetMap("mysql")
+	if db != nil && dbSqlite != nil {
+		SetSqliteDB(appIns, dbSqlite)
+	}
+	if db != nil && dbMysql != nil {
+		SetMysqlDB(appIns, dbMysql)
 	}
 }
+func SetMysqlDB(appIns *Application, config Map) {
+
+	appIns.Db.Type = "mysql"
+	appIns.Db.DBName = config.GetString("name")
+	appIns.Db.Prefix = config.GetString("prefix")
+	appIns.SetConnectDB(func(err ...*Error) (master, slave *sql.DB) {
+		//master数据库配置
+		query := config.GetString("user") + ":" + config.GetString("password") +
+			"@tcp(" + config.GetString("host") + ":" + config.GetString("port") + ")/" + config.GetString("name") + "?charset=utf8"
+		DB, e := sql.Open("mysql", query)
+		if e != nil && len(err) != 0 {
+			err[0].SetError(e)
+		}
+		master = DB
+		//slave数据库配置
+		configSlave := config.GetMap("slave")
+		if configSlave != nil {
+			query := configSlave.GetString("user") + ":" + configSlave.GetString("password") +
+				"@tcp(" + config.GetString("host") + ":" + configSlave.GetString("port") + ")/" + configSlave.GetString("name") + "?charset=utf8"
+			DB1, e := sql.Open("mysql", query)
+			if e != nil && len(err) != 0 {
+				err[0].SetError(e)
+			}
+			slave = DB1
+		}
+
+		return master, slave
+		//return DB
+	})
+}
+func SetSqliteDB(appIns *Application, config Map) {
+
+	appIns.Db.Type = "sqlite"
+	appIns.Db.Prefix = config.GetString("prefix")
+	appIns.SetConnectDB(func(err ...*Error) (master, slave *sql.DB) {
+		db, e := sql.Open("sqlite3", config.GetString("path"))
+		if e != nil && len(err) != 0 {
+			err[0].SetError(e)
+		}
+		master = db
+
+		return master, slave
+	})
+}
+
+func setMakeCodeLintener(name string, appIns *Application) {
+	appIns.SetConnectListener(func(context *Context) bool {
+		if len(context.RouterString) < 2 || appIns.MakeCodeRouter[context.RouterString[0]] == nil {
+			return true
+		}
+		if len(context.RouterString) > 1 && context.RouterString[0] == name {
+			if context.RouterString[1] == "hotime" && context.RouterString[2] == "login" {
+				return true
+			}
+			if context.RouterString[1] == "hotime" && context.RouterString[2] == "logout" {
+				return true
+			}
+
+			if context.Session(name+"_id").Data == nil {
+				context.Display(2, "你还没有登录")
+				return false
+			}
+		}
+
+		//文件上传接口
+		if len(context.RouterString) == 1 && context.RouterString[0] == "file" && context.Req.Method == "POST" {
+			if context.Session(name+"_id").Data == nil {
+				context.Display(2, "你还没有登录")
+				return false
+			}
+			//读取网络文件
+			fi, fheader, err := context.Req.FormFile("file")
+			if err != nil {
+				context.Display(3, err)
+				return false
+
+			}
+			filePath := context.Config.GetString("filePath")
+			if filePath == "" {
+				filePath = "file/2006/01/02/"
+			}
+
+			path := time.Now().Format(filePath)
+			e := os.MkdirAll(context.Config.GetString("tpt")+"/"+path, os.ModeDir)
+			if e != nil {
+				context.Display(3, e)
+				return false
+			}
+			filePath = path + Md5(ObjToStr(RandX(100000, 9999999))) + fheader.Filename[strings.LastIndex(fheader.Filename, "."):]
+			newFile, e := os.Create(context.Config.GetString("tpt") + "/" + filePath)
+
+			if e != nil {
+				context.Display(3, e)
+				return false
+			}
+
+			_, e = io.Copy(newFile, fi)
+
+			if e != nil {
+				context.Display(3, e)
+				return false
+			}
+
+			context.Display(0, filePath)
+			return false
+		}
+
+		if len(context.RouterString) < 2 || len(context.RouterString) > 3 ||
+			!(context.Router[context.RouterString[0]] != nil &&
+				context.Router[context.RouterString[0]][context.RouterString[1]] != nil) {
+			return true
+		}
+		//排除无效操作
+		if len(context.RouterString) == 2 &&
+			context.Req.Method != "GET" &&
+			context.Req.Method != "POST" {
+			return true
+		}
+		//列表检索
+		if len(context.RouterString) == 2 &&
+			context.Req.Method == "GET" {
+			if context.Router[context.RouterString[0]][context.RouterString[1]]["search"] == nil {
+				return true
+			}
+			context.Router[context.RouterString[0]][context.RouterString[1]]["search"](context)
+		}
+		//新建
+		if len(context.RouterString) == 2 &&
+			context.Req.Method == "POST" {
+			if context.Router[context.RouterString[0]][context.RouterString[1]]["add"] == nil {
+				return true
+			}
+			context.Router[context.RouterString[0]][context.RouterString[1]]["add"](context)
+		}
+		if len(context.RouterString) == 3 &&
+			context.Req.Method == "POST" {
+			return true
+		}
+		//查询单条
+		if len(context.RouterString) == 3 &&
+			context.Req.Method == "GET" {
+
+			if context.Router[context.RouterString[0]][context.RouterString[1]]["info"] == nil {
+				return true
+			}
+
+			context.Router[context.RouterString[0]][context.RouterString[1]]["info"](context)
+		}
+		//更新
+		if len(context.RouterString) == 3 &&
+			context.Req.Method == "PUT" {
+
+			if context.Router[context.RouterString[0]][context.RouterString[1]]["update"] == nil {
+				return true
+			}
+
+			context.Router[context.RouterString[0]][context.RouterString[1]]["update"](context)
+		}
+		//移除
+		if len(context.RouterString) == 3 &&
+			context.Req.Method == "DELETE" {
+
+			if context.Router[context.RouterString[0]][context.RouterString[1]]["remove"] == nil {
+				return true
+			}
+
+			context.Router[context.RouterString[0]][context.RouterString[1]]["remove"](context)
+		}
+		context.View()
+		return false
+	})
+}

cache/cache.go

@@ -0,0 +1,277 @@
+package cache
+
+import (
+	. "../common"
+	"errors"
+)
+
+// HoTimeCache 可配置memory，db，redis，默认启用memory，默认优先级为memory>redis>db,memory与数据库缓存设置项一致，
+//缓存数据填充会自动反方向反哺，加入memory缓存过期将自动从redis更新，但memory永远不会更新redis，如果是集群建议不要开启memory，配置即启用
+type HoTimeCache struct {
+	*Error
+	dbCache     *CacheDb
+	redisCache  *CacheRedis
+	memoryCache *CacheMemory
+	Config      Map
+}
+
+func (that *HoTimeCache) Session(key string, data ...interface{}) *Obj {
+	var reData *Obj
+	if len(data) == 0 {
+		//内存缓存有
+		if that.memoryCache != nil && that.memoryCache.SessionSet {
+			reData = that.memoryCache.Cache(key, data...)
+			if reData.Data != nil {
+				return reData
+			}
+		}
+
+		//redis缓存有
+		if that.redisCache != nil && that.redisCache.SessionSet {
+			reData = that.redisCache.Cache(key, data...)
+			if reData.Data != nil {
+				if that.memoryCache != nil && that.memoryCache.SessionSet {
+					that.memoryCache.Cache(key, reData.Data)
+				}
+				return reData
+			}
+		}
+
+		//db缓存有
+		if that.dbCache != nil && that.dbCache.SessionSet {
+			reData = that.dbCache.Cache(key, data...)
+			if reData.Data != nil {
+				if that.memoryCache != nil && that.memoryCache.SessionSet {
+					that.memoryCache.Cache(key, reData.Data)
+				}
+				if that.redisCache != nil && that.redisCache.SessionSet {
+					that.redisCache.Cache(key, reData.Data)
+				}
+
+				return reData
+			}
+		}
+		return reData
+	}
+
+	//设置缓存
+	//设置内存缓存
+	if that.memoryCache != nil && that.memoryCache.SessionSet {
+		reData = that.memoryCache.Cache(key, data...)
+	}
+	//redis缓存有
+	if that.redisCache != nil && that.redisCache.SessionSet {
+		reData = that.redisCache.Cache(key, data...)
+	}
+	//redis缓存有
+	if that.dbCache != nil && that.dbCache.SessionSet {
+		reData = that.dbCache.Cache(key, data...)
+	}
+	return reData
+
+}
+func (that *HoTimeCache) Db(key string, data ...interface{}) *Obj {
+	var reData *Obj
+	if len(data) == 0 {
+		//内存缓存有
+		if that.memoryCache != nil && that.memoryCache.DbSet {
+			reData = that.memoryCache.Cache(key, data...)
+			if reData.Data != nil {
+				return reData
+			}
+		}
+
+		//redis缓存有
+		if that.redisCache != nil && that.redisCache.DbSet {
+			reData = that.redisCache.Cache(key, data...)
+			if reData.Data != nil {
+				if that.memoryCache != nil && that.memoryCache.DbSet {
+					that.memoryCache.Cache(key, reData.Data)
+				}
+				return reData
+			}
+		}
+
+		//redis缓存有
+		if that.dbCache != nil && that.dbCache.DbSet {
+			reData = that.dbCache.Cache(key, data...)
+			if reData.Data != nil {
+				if that.memoryCache != nil && that.memoryCache.DbSet {
+					that.memoryCache.Cache(key, reData.Data)
+				}
+
+				if that.redisCache != nil && that.redisCache.DbSet {
+					that.redisCache.Cache(key, reData.Data)
+				}
+
+				return reData
+			}
+		}
+		return reData
+	}
+
+	//设置缓存
+	//设置内存缓存
+	if that.memoryCache != nil && that.memoryCache.DbSet {
+		reData = that.memoryCache.Cache(key, data...)
+	}
+	//redis缓存有
+	if that.redisCache != nil && that.redisCache.DbSet {
+		reData = that.redisCache.Cache(key, data...)
+	}
+	//redis缓存有
+	if that.dbCache != nil && that.dbCache.DbSet {
+		reData = that.dbCache.Cache(key, data...)
+	}
+	return reData
+}
+
+func (that *HoTimeCache) Cache(key string, data ...interface{}) *Obj {
+	var reData *Obj
+	if len(data) == 0 {
+		//内存缓存有
+		if that.memoryCache != nil {
+			reData = that.memoryCache.Cache(key, data...)
+			if reData != nil {
+				return reData
+			}
+		}
+
+		//redis缓存有
+		if that.redisCache != nil {
+			reData = that.redisCache.Cache(key, data...)
+			if reData.Data != nil {
+
+				if that.memoryCache != nil {
+					that.memoryCache.Cache(key, reData.Data)
+				}
+				return reData
+			}
+		}
+
+		//redis缓存有
+		if that.dbCache != nil {
+			reData = that.dbCache.Cache(key, data...)
+			if reData.Data != nil {
+				if that.memoryCache != nil {
+					that.memoryCache.Cache(key, reData.Data)
+				}
+				if that.redisCache != nil {
+					that.redisCache.Cache(key, reData.Data)
+				}
+				return reData
+			}
+		}
+		return reData
+	}
+
+	//设置缓存
+	//设置内存缓存
+	if that.memoryCache != nil {
+		reData = that.memoryCache.Cache(key, data...)
+	}
+	//redis缓存有
+	if that.redisCache != nil {
+		reData = that.redisCache.Cache(key, data...)
+	}
+	//redis缓存有
+	if that.dbCache != nil {
+		reData = that.dbCache.Cache(key, data...)
+	}
+	return reData
+}
+
+func (that *HoTimeCache) Init(config Map, hotimeDb HoTimeDBInterface, err ...*Error) {
+	//防止空数据问题
+	if config == nil {
+		config = Map{}
+	}
+	if err[0] != nil {
+		that.Error = err[0]
+	}
+	that.Config = config
+	//memory配置初始化
+	memory := that.Config.GetMap("memory")
+	if memory == nil {
+		memory = Map{
+			"db":      true,
+			"session": true,
+			"sort":    0,
+			"timeout": 60 * 60 * 2,
+		}
+
+	}
+	if memory.Get("db") == nil {
+		memory["db"] = true
+	}
+
+	if memory.Get("session") == nil {
+		memory["session"] = true
+	}
+
+	if memory.Get("timeout") == nil {
+		memory["timeout"] = 60 * 60 * 2
+	}
+	that.Config["memory"] = memory
+	that.memoryCache = &CacheMemory{TimeOut: memory.GetCeilInt64("timeout"),
+		DbSet: memory.GetBool("db"), SessionSet: memory.GetBool("session")}
+	if err[0] != nil {
+		that.memoryCache.SetError(err[0])
+	}
+
+	//db配置初始化
+	redis := that.Config.GetMap("redis")
+	if redis != nil {
+		if redis.GetString("host") == "" || redis.GetString("port") == "" {
+			if err[0] != nil {
+				err[0].SetError(errors.New("请检查redis配置host和port配置"))
+			}
+			return
+		}
+		if redis.Get("db") == nil {
+			redis["db"] = true
+		}
+
+		if redis.Get("session") == nil {
+			redis["session"] = true
+		}
+
+		if redis.Get("timeout") == nil {
+			redis["timeout"] = 60 * 60 * 24 * 15
+		}
+		that.Config["redis"] = redis
+		that.redisCache = &CacheRedis{TimeOut: redis.GetCeilInt64("timeout"),
+			DbSet: redis.GetBool("db"), SessionSet: redis.GetBool("session"), Host: redis.GetString("host"),
+			Pwd: redis.GetString("password"), Port: redis.GetCeilInt64("port")}
+
+		if err[0] != nil {
+			that.redisCache.SetError(err[0])
+		}
+	}
+
+	//db配置初始化
+	db := that.Config.GetMap("db")
+	if db != nil {
+
+		if db.Get("db") == nil {
+			db["db"] = false
+		}
+
+		if db.Get("session") == nil {
+			db["session"] = true
+		}
+		if db.Get("timeout") == nil {
+			db["timeout"] = 60 * 60 * 24 * 30
+		}
+		that.Config["db"] = db
+
+		that.dbCache = &CacheDb{TimeOut: db.GetCeilInt64("timeout"),
+			DbSet: db.GetBool("db"), SessionSet: db.GetBool("session"),
+			Db: hotimeDb}
+
+		if err[0] != nil {
+			that.dbCache.SetError(err[0])
+		}
+	}
+
+}

cache/cache_db.go

@@ -0,0 +1,173 @@
+package cache
+
+import (
+	. "../common"
+	"database/sql"
+	"encoding/json"
+	"strings"
+	"time"
+)
+
+type HoTimeDBInterface interface {
+	GetPrefix() string
+	Query(query string, args ...interface{}) []Map
+	Exec(query string, args ...interface{}) (sql.Result, *Error)
+	Get(table string, qu ...interface{}) Map
+	Select(table string, qu ...interface{}) []Map
+	Delete(table string, data map[string]interface{}) int64
+	Update(table string, data Map, where Map) int64
+	Insert(table string, data map[string]interface{}) int64
+	GetType() string
+}
+
+type CacheDb struct {
+	TimeOut    int64
+	DbSet      bool
+	SessionSet bool
+	Db         HoTimeDBInterface
+	*Error
+	ContextBase
+	isInit bool
+}
+
+func (this *CacheDb) GetError() *Error {
+
+	return this.Error
+
+}
+
+func (this *CacheDb) SetError(err *Error) {
+	this.Error = err
+}
+
+func (that *CacheDb) initDbTable() {
+	if that.isInit {
+		return
+	}
+	if that.Db.GetType() == "mysql" {
+
+		dbNames := that.Db.Query("SELECT DATABASE()")
+
+		if len(dbNames) == 0 {
+			return
+		}
+		dbName := dbNames[0].GetString("DATABASE()")
+		res := that.Db.Query("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA='" + dbName + "' AND TABLE_NAME='" + that.Db.GetPrefix() + "cached'")
+		if len(res) != 0 {
+			that.isInit = true
+			return
+		}
+
+		_, e := that.Db.Exec("CREATE TABLE `" + that.Db.GetPrefix() + "cached` ( `id` int(11) unsigned NOT NULL AUTO_INCREMENT, `ckey` varchar(60) DEFAULT NULL, `cvalue` varchar(2000) DEFAULT NULL, `time` bigint(20) DEFAULT NULL, `endtime` bigint(20) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=198740 DEFAULT CHARSET=utf8")
+		if e.GetError() == nil {
+			that.isInit = true
+		}
+
+	}
+
+	if that.Db.GetType() == "sqlite" {
+		res := that.Db.Query(`select * from sqlite_master where type = 'table' and name = '` + that.Db.GetPrefix() + `cached'`)
+
+		if len(res) != 0 {
+			that.isInit = true
+			return
+		}
+		_, e := that.Db.Exec(`CREATE TABLE "` + that.Db.GetPrefix() + `cached" (
+			"id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+				"ckey" TEXT(60),
+				"cvalue" TEXT(2000),
+				"time" integer,
+				"endtime" integer
+			);`)
+		if e.GetError() == nil {
+			that.isInit = true
+		}
+
+	}
+
+}
+
+//获取Cache键只能为string类型
+func (that *CacheDb) get(key string) interface{} {
+
+	cached := that.Db.Get("cached", "*", Map{"ckey": key})
+
+	if cached == nil {
+		return nil
+	}
+	//data:=cacheMap[key];
+	if cached.GetInt64("endtime") <= time.Now().Unix() {
+
+		that.Db.Delete("cached", Map{"id": cached.GetString("id")})
+		return nil
+	}
+
+	data := Map{}
+	data.JsonToMap(cached.GetString("cvalue"))
+
+	return data.Get("data")
+}
+
+//key value ,时间为时间戳
+func (that *CacheDb) set(key string, value interface{}, tim int64) {
+
+	bte, _ := json.Marshal(Map{"data": value})
+
+	num := that.Db.Update("cached", Map{"cvalue": string(bte), "time": time.Now().UnixNano(), "endtime": tim}, Map{"ckey": key})
+	if num == int64(0) {
+		that.Db.Insert("cached", Map{"cvalue": string(bte), "time": time.Now().UnixNano(), "endtime": tim, "ckey": key})
+	}
+
+	//随机执行删除命令
+	if Rand(1000) > 950 {
+		that.Db.Delete("cached", Map{"endtime[<]": time.Now().Unix()})
+	}
+}
+
+func (that *CacheDb) delete(key string) {
+
+	del := strings.Index(key, "*")
+	//如果通配删除
+	if del != -1 {
+		key = Substr(key, 0, del)
+		that.Db.Delete("cached", Map{"ckey": key + "%"})
+
+	} else {
+		that.Db.Delete("cached", Map{"ckey": key})
+	}
+}
+
+func (that *CacheDb) Cache(key string, data ...interface{}) *Obj {
+
+	that.initDbTable()
+
+	if len(data) == 0 {
+		return &Obj{Data: that.get(key)}
+	}
+	tim := time.Now().Unix()
+
+	if len(data) == 1 && data[0] == nil {
+		that.delete(key)
+		return &Obj{Data: nil}
+	}
+
+	if len(data) == 1 {
+		if that.TimeOut == 0 {
+			//that.Time = Config.GetInt64("cacheLongTime")
+		}
+		tim += that.TimeOut
+	}
+	if len(data) == 2 {
+		that.SetError(nil)
+		tempt := ObjToInt64(data[1], that.Error)
+
+		if tempt > tim {
+			tim = tempt
+		} else if that.GetError() == nil {
+
+			tim = tim + tempt
+		}
+	}
+	that.set(key, data[0], tim)
+	return &Obj{Data: nil}
+}

cache/cache_memory.go

@@ -1,18 +1,32 @@
-package hotime
+package cache
 
 import (
+	. "../common"
 	"strings"
 	"sync"
 	"time"
 )
 
 type CacheMemory struct {
-	Time int64
+	TimeOut    int64
+	DbSet      bool
+	SessionSet bool
 	Map
-	contextBase
+	*Error
+	ContextBase
 	mutex *sync.RWMutex
 }
 
+func (this *CacheMemory) GetError() *Error {
+
+	return this.Error
+
+}
+
+func (this *CacheMemory) SetError(err *Error) {
+	this.Error = err
+}
+
 //获取Cache键只能为string类型
 func (this *CacheMemory) get(key string) interface{} {
 	this.Error.SetError(nil)
@@ -23,8 +37,8 @@ func (this *CacheMemory) get(key string) interface{} {
 	if this.Map[key] == nil {
 		return nil
 	}
-	data := this.Map.Get(key, &this.Error).(cacheData)
-	if this.GetError() != nil {
+	data := this.Map.Get(key, this.Error).(cacheData)
+	if this.Error.GetError() != nil {
 		return nil
 	}
 
@@ -81,7 +95,8 @@ func (this *CacheMemory) delete(key string) {
 		key = Substr(key, 0, del)
 		for k, _ := range this.Map {
 			if strings.Index(k, key) != -1 {
-				delete(this.Map, key)
+				delete(this.Map, k)
+
 			}
 		}
 
@@ -119,21 +134,18 @@ func (this *CacheMemory) Cache(key string, data ...interface{}) *Obj {
 	}
 
 	if len(data) == 1 {
-		if this.Time == 0 {
-			this.Time = Config.GetInt64("cacheShortTime")
-		}
 
-		tim = tim + this.Time
+		tim = tim + this.TimeOut
 
 	}
 	if len(data) == 2 {
 		this.Error.SetError(nil)
-		tempt := ObjToInt64(data[1], &this.Error)
+		tempt := ObjToInt64(data[1], this.Error)
 
 		if tempt > tim {
 
 			tim = tempt
-		} else if this.GetError() == nil {
+		} else if this.Error.GetError() == nil {
 
 			tim = tim + tempt
 		}

cache/cache_redis.go

@@ -1,19 +1,33 @@
 package cache
 
 import (
-	. "code.hoteas.com/golang/hotime"
+	. "../common"
 	"github.com/garyburd/redigo/redis"
 	"strings"
 	"time"
 )
 
 type CacheRedis struct {
-	Host string
-	Pwd  string
-	Time int64
-	conn redis.Conn
-	tag  int64
-	Error
+	TimeOut    int64
+	DbSet      bool
+	SessionSet bool
+	Host       string
+	Pwd        string
+	Port       int64
+	conn       redis.Conn
+	tag        int64
+	ContextBase
+	*Error
+}
+
+func (this *CacheRedis) GetError() *Error {
+
+	return this.Error
+
+}
+
+func (this *CacheRedis) SetError(err *Error) {
+	this.Error = err
 }
 
 //唯一标志
@@ -27,19 +41,22 @@ func (this *CacheRedis) GetTag() int64 {
 
 func (this *CacheRedis) reCon() bool {
 	var err error
-	this.conn, err = redis.Dial("tcp", this.Host)
+	this.conn, err = redis.Dial("tcp", this.Host+":"+ObjToStr(this.Port))
 	if err != nil {
 		this.conn = nil
 		this.Error.SetError(err)
 		return false
 	}
 
-	_, err = this.conn.Do("AUTH", this.Pwd)
-	if err != nil {
-		this.conn = nil
-		this.Error.SetError(err)
-		return false
+	if this.Pwd != "" {
+		_, err = this.conn.Do("AUTH", this.Pwd)
+		if err != nil {
+			this.conn = nil
+			this.Error.SetError(err)
+			return false
+		}
 	}
+
 	return true
 }
 func (this *CacheRedis) del(key string) {
@@ -128,15 +145,15 @@ func (this *CacheRedis) Cache(key string, data ...interface{}) *Obj {
 	//添加缓存
 	if len(data) == 1 {
 
-		if this.Time == 0 {
-			this.Time = Config.GetInt64("cacheShortTime")
+		if this.TimeOut == 0 {
+			//this.Time = Config.GetInt64("cacheShortTime")
 		}
 
-		tim += this.Time
+		tim += this.TimeOut
 	}
 	if len(data) == 2 {
 		this.Error.SetError(nil)
-		tempt := ObjToInt64(data[1], &this.Error)
+		tempt := ObjToInt64(data[1], this.Error)
 		if tempt > tim {
 
 			tim = tempt

cache/type.go

@@ -1,16 +1,15 @@
-package hotime
+package cache
 
-//控制器
-type Ctr map[string]Method
-type Proj map[string]Ctr
-type Router map[string]Proj
-type MethodRouter map[string]Method //直接字符串关联函数
-type Method func(this *Context)
+import (
+	. "../common"
+)
 
 type CacheIns interface {
 	//set(key string, value interface{}, time int64)
 	//get(key string) interface{}
 	//delete(key string)
+	GetError() *Error
+	SetError(err *Error)
 	Cache(key string, data ...interface{}) *Obj
 }
 

cache_db.go

@@ -1,146 +0,0 @@
-package hotime
-
-import (
-	"encoding/json"
-	"strings"
-	"time"
-)
-
-type CacheDb struct {
-	Time int64
-	Db   *HoTimeDB
-	contextBase
-	isInit bool
-}
-
-func (this *CacheDb) initDbTable() {
-	if this.isInit {
-		return
-	}
-	if this.Db.Type == "mysql" {
-
-		dbNames := this.Db.Query("SELECT DATABASE()")
-
-		if len(dbNames) == 0 {
-			return
-		}
-		dbName := dbNames[0].GetString("DATABASE()")
-		res := this.Db.Query("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA='" + dbName + "' AND TABLE_NAME='cached'")
-		if len(res) != 0 {
-			this.isInit = true
-			return
-		}
-
-		_, e := this.Db.Exec("CREATE TABLE `cached` ( `id` int(11) unsigned NOT NULL AUTO_INCREMENT, `ckey` varchar(60) DEFAULT NULL, `cvalue` varchar(2000) DEFAULT NULL, `time` bigint(20) DEFAULT NULL, `endtime` bigint(20) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=198740 DEFAULT CHARSET=utf8")
-		if e.GetError() == nil {
-			this.isInit = true
-		}
-
-	}
-
-	if this.Db.Type == "sqlite" {
-		res := this.Db.Query(`select * from sqlite_master where type = 'table' and name = 'cached'`)
-
-		if len(res) != 0 {
-			this.isInit = true
-			return
-		}
-		_, e := this.Db.Exec(`CREATE TABLE "cached" (
-			"id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
-				"ckey" TEXT(60),
-				"cvalue" TEXT(2000),
-				"time" integer,
-				"endtime" integer
-			);`)
-		if e.GetError() == nil {
-			this.isInit = true
-		}
-
-	}
-
-}
-
-//获取Cache键只能为string类型
-func (this *CacheDb) get(key string) interface{} {
-
-	cached := this.Db.Get("cached", "*", Map{"ckey": key})
-
-	if cached == nil {
-		return nil
-	}
-	//data:=cacheMap[key];
-	if cached.GetInt64("endtime") <= time.Now().Unix() {
-
-		this.Db.Delete("cached", Map{"id": cached.GetString("id")})
-		return nil
-	}
-
-	data := Map{}
-	data.JsonToMap(cached.GetString("cvalue"))
-
-	return data.Get("data")
-}
-
-//key value ,时间为时间戳
-func (this *CacheDb) set(key string, value interface{}, tim int64) {
-
-	bte, _ := json.Marshal(Map{"data": value})
-
-	num := this.Db.Update("cached", Map{"cvalue": string(bte), "time": time.Now().UnixNano(), "endtime": tim}, Map{"ckey": key})
-	if num == int64(0) {
-		this.Db.Insert("cached", Map{"cvalue": string(bte), "time": time.Now().UnixNano(), "endtime": tim, "ckey": key})
-	}
-
-	//随机执行删除命令
-	if Rand(1000) > 950 {
-		this.Db.Delete("cached", Map{"endtime[<]": time.Now().Unix()})
-	}
-}
-
-func (this *CacheDb) delete(key string) {
-
-	del := strings.Index(key, "*")
-	//如果通配删除
-	if del != -1 {
-		key = Substr(key, 0, del)
-		this.Db.Delete("cached", Map{"ckey": key + "%"})
-
-	} else {
-		this.Db.Delete("cached", Map{"ckey": key})
-	}
-}
-
-func (this *CacheDb) Cache(key string, data ...interface{}) *Obj {
-
-	this.initDbTable()
-
-	if len(data) == 0 {
-		return &Obj{Data: this.get(key)}
-	}
-	tim := time.Now().Unix()
-
-	if len(data) == 1 && data[0] == nil {
-		this.delete(key)
-		return &Obj{Data: nil}
-	}
-
-	if len(data) == 1 {
-		if this.Time == 0 {
-			this.Time = Config.GetInt64("cacheLongTime")
-		}
-		tim += this.Time
-	}
-	if len(data) == 2 {
-		this.SetError(nil)
-		tempt := ObjToInt64(data[1], &this.Error)
-
-		if tempt > tim {
-			tim = tempt
-		} else if this.GetError() == nil {
-
-			tim = tim + tempt
-		}
-	}
-	this.set(key, data[0], tim)
-	return &Obj{Data: nil}
-}

code.go

@@ -0,0 +1,232 @@
+package hotime
+
+import (
+	. "./common"
+	"strings"
+)
+
+// Project 管理端项目
+var TptProject = Proj{
+	//"user": UserCtr,
+	"hotimeCommon": Ctr{
+		"info": func(that *Context) {
+			hotimeName := that.RouterString[0]
+			data := that.Db.Get(hotimeName, "*", Map{"id": that.Session(hotimeName + "_id").ToCeilInt()})
+			str, inData := that.MakeCode.Info(that.RouterString[1], data, that.Db)
+			where := Map{"id": that.RouterString[2]}
+
+			if len(inData) == 1 {
+				inData["id"] = where["id"]
+				where = Map{"AND": inData}
+			} else if len(inData) > 1 {
+				where["OR"] = inData
+				where = Map{"AND": where}
+			}
+
+			re := that.Db.Get(that.RouterString[1], str, where)
+
+			if re == nil {
+				that.Display(4, "找不到对应信息")
+				return
+			}
+
+			for k, v := range re {
+				column := that.MakeCode.TableColumns[that.RouterString[1]][k]
+				if column == nil {
+					continue
+				}
+				if (column["list"] == nil || column.GetBool("list")) && column.GetString("link") != "" {
+					re[column.GetString("link")] = that.Db.Get(column.GetString("link"), "id,"+column.GetString("value"), Map{"id": v})
+				}
+			}
+
+			that.Display(0, re)
+		},
+		"add": func(that *Context) {
+			inData := that.MakeCode.Add(that.RouterString[1], that.Req)
+			if inData == nil {
+				that.Display(3, "请求参数不足")
+				return
+			}
+
+			re := that.Db.Insert(that.RouterString[1], inData)
+
+			if re == 0 {
+				that.Display(4, "无法插入对应数据")
+				return
+			}
+			//索引管理，便于检索以及权限
+			if inData.Get("parent_id") != nil && inData.GetString("index") != "" {
+				index := that.Db.Get(that.RouterString[1], "`index`", Map{"id": inData.Get("parent_id")})
+				inData["index"] = index.GetString("index") + ObjToStr(re) + ","
+				that.Db.Update(that.RouterString[1], Map{"index": inData["index"]}, Map{"id": re})
+			} else if inData.GetString("index") != "" {
+				inData["index"] = "," + ObjToStr(re) + ","
+				that.Db.Update(that.RouterString[1], Map{"index": inData["index"]}, Map{"id": re})
+			}
+
+			that.Display(0, re)
+		},
+		"update": func(that *Context) {
+			inData := that.MakeCode.Edit(that.RouterString[1], that.Req)
+			if inData == nil {
+				that.Display(3, "没有找到要更新的数据")
+				return
+			}
+
+			//索引管理，便于检索以及权限
+			if inData.GetString("index") != "" {
+				if inData.Get("parent_id") != nil {
+					Index := that.Db.Get(that.RouterString[1], "`index`", Map{"id": that.RouterString[2]})
+					parentIndex := that.Db.Get(that.RouterString[1], "`index`", Map{"id": inData.Get("parent_id")})
+					inData["index"] = parentIndex.GetString("index") + that.RouterString[2] + ","
+
+					childNodes := that.Db.Select(that.RouterString[1], "id,`index``", Map{"index[~]": "," + that.RouterString[2] + ","})
+
+					for _, v := range childNodes {
+						v["index"] = strings.Replace(v.GetString("index"), Index.GetString("index"), inData.GetString("index"), -1)
+						that.Db.Update(that.RouterString[1], Map{"index": v["index"]}, Map{"id": v.GetCeilInt("id")})
+					}
+				} else {
+					delete(inData, "index")
+				}
+
+			}
+
+			re := that.Db.Update(that.RouterString[1], inData, Map{"id": that.RouterString[2]})
+
+			if re == 0 {
+				that.Display(4, "更新数据失败")
+				return
+			}
+
+			that.Display(0, re)
+		},
+		"remove": func(that *Context) {
+			inData := that.MakeCode.Delete(that.RouterString[1], that.Req)
+			if inData == nil {
+				that.Display(3, "请求参数不足")
+				return
+			}
+			re := int64(0)
+			//索引管理，便于检索以及权限
+			if inData.Get("parent_id") != nil && inData.GetSlice("index") != nil {
+				re = that.Db.Delete(that.RouterString[1], Map{"index[~]": "," + that.RouterString[2] + ","})
+			} else {
+				re = that.Db.Delete(that.RouterString[1], Map{"id": that.RouterString[2]})
+			}
+
+			if re == 0 {
+				that.Display(4, "删除数据失败")
+				return
+			}
+			that.Display(0, "删除成功")
+		},
+
+		"search": func(that *Context) {
+			hotimeName := that.RouterString[0]
+			data := that.Db.Get(hotimeName, "*", Map{"id": that.Session(hotimeName + "_id").ToCeilInt()})
+
+			columnStr, leftJoin, where := that.MakeCode.Search(that.RouterString[1], data, that.Req, that.Db)
+
+			page := ObjToInt(that.Req.FormValue("page"))
+			pageSize := ObjToInt(that.Req.FormValue("pageSize"))
+
+			if page < 1 {
+				page = 1
+			}
+
+			if pageSize <= 0 {
+				pageSize = 20
+			}
+
+			count := that.Db.Count(that.RouterString[1], leftJoin, where)
+			reData := that.Db.Page(page, pageSize).
+				PageSelect(that.RouterString[1], leftJoin, columnStr, where)
+
+			for _, v := range reData {
+				for k, _ := range v {
+					column := that.MakeCode.TableColumns[that.RouterString[1]][k]
+					if column == nil {
+						continue
+					}
+
+					if column["list"] != false && column["name"] == "parent_id" && column.GetString("link") != "" {
+						parentC := that.Db.Get(column.GetString("link"), column.GetString("value"), Map{"id": v.GetCeilInt(k)})
+						v[column.GetString("link")+"_"+column.GetString("name")+"_"+column.GetString("value")] = ""
+						if parentC != nil {
+							v[column.GetString("link")+"_"+column.GetString("name")+"_"+column.GetString("value")] = parentC.GetString(column.GetString("value"))
+						}
+					}
+
+				}
+			}
+
+			that.Display(0, Map{"count": count, "data": reData})
+		},
+	},
+	"hotime": Ctr{
+		"login": func(this *Context) {
+			hotimeName := this.RouterString[0]
+			name := this.Req.FormValue("name")
+			password := this.Req.FormValue("password")
+			if name == "" || password == "" {
+				this.Display(3, "参数不足")
+				return
+			}
+			user := this.Db.Get(hotimeName, "*", Map{"AND": Map{"OR": Map{"name": name, "phone": name}, "password": Md5(password)}})
+			if user == nil {
+				this.Display(5, "登录失败")
+				return
+			}
+			this.Session(hotimeName+"_id", user.GetCeilInt("id"))
+			this.Session(hotimeName+"_name", name)
+			delete(user, "password")
+			this.Display(0, user)
+		},
+		"logout": func(this *Context) {
+			hotimeName := this.RouterString[0]
+			this.Session(hotimeName+"_id", nil)
+			this.Session(hotimeName+"_name", nil)
+			this.Display(0, "退出登录成功")
+		},
+		"info": func(that *Context) {
+			hotimeName := that.RouterString[0]
+			data := that.Db.Get(hotimeName, "*", Map{"id": that.Session(hotimeName + "_id").ToCeilInt()})
+			str, inData := that.MakeCode.Info(hotimeName, data, that.Db)
+			where := Map{"id": that.Session(hotimeName + "_id").ToCeilInt()}
+			if len(inData) == 1 {
+				inData["id"] = where["id"]
+				where = Map{"AND": inData}
+			} else if len(inData) > 1 {
+				where["OR"] = inData
+				where = Map{"AND": where}
+			}
+			re := that.Db.Get(hotimeName, str, where)
+			if re == nil {
+				that.Display(4, "找不到对应信息")
+				return
+			}
+			for k, v := range re {
+				column := that.MakeCode.TableColumns[hotimeName][k]
+				if column == nil {
+					continue
+				}
+				if (column["list"] == nil || column.GetBool("list")) && column.GetString("link") != "" {
+
+					//是角色表则取下角色值
+					if column.GetString("link") == "role" {
+
+						re[column.GetString("link")] = that.Db.Get(column.GetString("link"), "id,auth,"+column.GetString("value"), Map{"id": v})
+
+					} else {
+
+						re[column.GetString("link")] = that.Db.Get(column.GetString("link"), "id,"+column.GetString("value"), Map{"id": v})
+					}
+				}
+			}
+
+			that.Display(0, re)
+		},
+	},
+}

code/config.go

@@ -0,0 +1,103 @@
+package code
+
+import (
+	. "../common"
+)
+
+var Config = Map{
+	"name":  "HoTimeDashBoard",
+	"id":    "2f92h3herh23rh2y8",
+	"label": "HoTime管理平台",
+
+	"menus": []Map{
+		{"label": "平台首页", "name": "HelloWorld", "icon": "el-icon-s-home"},
+		//{"label": "测试表格", "table": "table", "icon": "el-icon-suitcase"},
+		//{"label": "系统管理", "name": "setting", "icon": "el-icon-setting",
+		//	"menus": []Map{
+		//		{"label": "用户管理", "table": "user",
+		//			"default": {
+		//				"path": "info",
+		//				"id": "1"
+		//			},
+		//			"auth": ["show","edit","info","add","delete"],
+		//		},
+		//		{"label": "组织管理", "table": "organization"},
+		//		{"label": "地区管理", "table": "area"},
+		//		{"label": "角色管理", "table": "role"},
+		//		{"label": "日志管理", "table": "log"},
+		//		{"label": "系统设置", "table": "system", "default": "edit"},
+		//	},
+		//},
+	},
+}
+var DefaultMenuParentName = "sys"
+
+var ColumnDataType = map[string]string{
+	//sqlite专有类型
+	"real": "number",
+	//mysql数据类型宽泛类型
+	"int":      "number",
+	"float":    "number",
+	"double":   "number",
+	"decimal":  "number",
+	"char":     "text",
+	"text":     "text",
+	"blob":     "text",
+	"date":     "time",
+	"time":     "time",
+	"year":     "time",
+	"geometry": "gis", //不建议使用gis类型，建议使用其他代替
+}
+
+type ColumnShow struct {
+	Name   string
+	List   bool
+	Edit   bool
+	Info   bool
+	Must   bool
+	Type   string //空字符串表示
+	Strict bool   //name严格匹配必须是这个词才行
+}
+
+var ColumnNameType = []ColumnShow{
+	//通用
+	{"idcard", false, true, true, false, "", false},
+	{"id", true, false, true, false, "", true},
+	{"parent_id", true, true, true, false, "", true},
+	//"sn"{true,true,true,""},
+	{"status", true, true, true, false, "select", false},
+	{"state", true, true, true, false, "select", false},
+	{"sex", true, true, true, false, "select", false},
+	{"delete", false, false, false, false, "", false},
+
+	{"lat", false, true, true, false, "", false},
+	{"lng", false, true, true, false, "", false},
+	{"latitude", false, true, true, false, "", false},
+	{"longitude", false, true, true, false, "", false},
+
+	{"index", false, false, false, false, "index", false},
+	{"password", false, true, false, false, "password", false},
+	{"pwd", false, true, false, false, "password", false},
+	{"info", false, true, true, false, "", false},
+	{"version", false, false, false, false, "", false},
+	{"seq", false, true, true, false, "", false},
+	{"sort", false, true, true, false, "", false},
+	{"note", false, true, true, false, "", false},
+	{"description", false, true, true, false, "", false},
+	{"abstract", false, true, true, false, "", false},
+	{"content", false, true, true, false, "", false},
+	{"address", false, true, true, false, "", false},
+	{"full_name", false, true, true, false, "", false},
+	{"create_time", false, false, true, false, "time", true},
+	{"modify_time", true, false, true, false, "time", true},
+	{"image", false, true, true, false, "image", false},
+	{"img", false, true, true, false, "image", false},
+	{"icon", false, true, true, false, "image", false},
+	{"avatar", false, true, true, false, "image", false},
+	{"file", false, true, true, false, "file", false},
+	{"age", false, true, true, false, "", false},
+	{"email", false, true, true, false, "", false},
+	{"time", true, true, true, true, "time", false},
+	{"level", false, false, true, false, "", false},
+	{"rule", true, true, true, false, "form", false},
+}

code/makecode.go

@@ -0,0 +1,883 @@
+package code
+
+import (
+	. "../common"
+	"../db"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+type MakeCode struct {
+	IndexMenus    Map
+	TableConfig   Map
+	TableColumns  map[string]map[string]Map
+	SearchColumns map[string]map[string]Map
+	Config        Map
+	Error
+}
+
+func (that *MakeCode) Db2JSON(name string, path string, db *db.HoTimeDB, makeCode bool) {
+	isMake := false
+	idSlice := Slice{}
+
+	if that.TableColumns == nil {
+		that.TableColumns = make(map[string]map[string]Map)
+	}
+	if that.SearchColumns == nil {
+		that.SearchColumns = make(map[string]map[string]Map)
+	}
+
+	//加载配置文件
+	btes, err := ioutil.ReadFile(path)
+	Config["name"] = name
+	that.Config = DeepCopyMap(Config).(Map)
+	if err == nil {
+		cmap := Map{}
+		//文件是否损坏
+		cmap.JsonToMap(string(btes), &that.Error)
+		for k, v := range cmap {
+			that.Config[k] = v //程序配置
+			Config[k] = v      //系统配置
+		}
+	} else {
+		that.Error.SetError(errors.New("配置文件不存在，或者配置出错，使用缺省默认配置"))
+	}
+	that.IndexMenus = Map{}
+	menusConfig := that.Config.GetSlice("menus")
+	//将配置写入到内存中仅作为判断用
+	if menusConfig != nil {
+		for kmenu, _ := range menusConfig {
+			menu := menusConfig.GetMap(kmenu)
+			if menu != nil {
+				mname := menu.GetString("table")
+				if mname == "" { //如果为空则不是表格
+					mname = menu.GetString("name")
+				}
+				that.IndexMenus[mname] = menu
+				childMenus := menu.GetSlice("menus")
+				if childMenus != nil {
+					for ckmenu, _ := range childMenus {
+						cmenu := childMenus.GetMap(ckmenu)
+						if cmenu != nil {
+							cname := cmenu.GetString("table")
+							if cmenu.GetString("table") == "" {
+								continue
+							}
+							that.IndexMenus[mname+"/"+cname] = cmenu
+						}
+
+					}
+
+				}
+
+			}
+
+		}
+	}
+
+	that.TableConfig = that.Config.GetMap("tables")
+	if that.TableConfig == nil {
+		that.TableConfig = Map{}
+	}
+
+	for tableName, _ := range that.TableConfig {
+
+		columns := that.TableConfig.GetMap(tableName).GetSlice("columns")
+		search := that.TableConfig.GetMap(tableName).GetSlice("search")
+		//初始化
+		if that.TableColumns[tableName] == nil {
+			that.TableColumns[tableName] = map[string]Map{}
+		}
+		//初始化搜索项
+		if that.SearchColumns[tableName] == nil {
+			that.SearchColumns[tableName] = map[string]Map{}
+		}
+
+		//注入源数据
+		for index, _ := range columns {
+			columnsName := columns.GetMap(index).GetString("name")
+			that.TableColumns[tableName][columnsName] = columns.GetMap(index)
+		}
+
+		//注入search源数据
+		for index, _ := range search {
+			searchName := search.GetMap(index).GetString("name")
+			that.SearchColumns[tableName][searchName] = search.GetMap(index)
+		}
+
+	}
+
+	if db == nil {
+
+		return
+	}
+
+	//数据库反哺
+	myInit := strings.Replace(InitTpt, "{{name}}", name, -1)
+	ctrList := ""
+
+	nowTables := make([]Map, 0)
+	if db.Type == "mysql" {
+		nowTables = db.Select("INFORMATION_SCHEMA.TABLES", "TABLE_NAME as name,TABLE_COMMENT as label", Map{"TABLE_SCHEMA": db.DBName})
+	}
+	if db.Type == "sqlite" {
+		nowTables = db.Select("sqlite_sequence", "name")
+	}
+	//idSlice=append(idSlice,nowTables)
+	for _, v := range nowTables {
+		if v.GetString("name") == "cached" {
+			continue
+		}
+		if that.TableConfig.GetMap(v.GetString("name")) == nil {
+			if v.GetString("label") == "" {
+				v["label"] = v.GetString("name")
+			}
+			that.TableConfig[v.GetString("name")] = Map{
+				"label":   v.GetString("label"),
+				"table":   v.GetString("name"),
+				"auth":    []string{"show", "add", "delete", "edit", "info"},
+				"columns": []Map{},
+				"search": []Map{
+
+					{"type": "search", "name": "keyword", "label": "请输入关键词", "value": nil},
+					{"type": "search", "name": "daterange", "label": "时间段", "value": nil},
+					{"type": "search", "name": "sort", "label": "排序", "value": nil},
+				},
+			}
+		}
+
+		//初始化
+		if that.TableColumns[v.GetString("name")] == nil {
+			that.TableColumns[v.GetString("name")] = make(map[string]Map)
+		}
+
+		//初始化
+		if that.SearchColumns[v.GetString("name")] == nil {
+			that.SearchColumns[v.GetString("name")] = make(map[string]Map)
+		}
+
+		tableInfo := make([]Map, 0)
+		if db.Type == "mysql" {
+			tableInfo = db.Select("INFORMATION_SCHEMA.COLUMNS", "COLUMN_NAME AS name,COLUMN_TYPE AS type,COLUMN_COMMENT AS label", Map{"AND": Map{"TABLE_SCHEMA": db.DBName, "TABLE_NAME": v.GetString("name")}})
+		}
+		if db.Type == "sqlite" {
+			tableInfo = db.Query("pragma table_info([" + v.GetString("name") + "]);")
+		}
+
+		idSlice = append(idSlice, tableInfo)
+		for _, info1 := range tableInfo {
+			info := DeepCopyMap(info1).(Map)
+			if info.GetString("label") == "" {
+				info["label"] = info.GetString("name")
+			}
+			coloum := that.TableColumns[v.GetString("name")][info.GetString("name")]
+
+			if coloum == nil {
+				//根据类型判断真实类型
+				for k, v1 := range ColumnDataType {
+					if strings.Contains(info.GetString("name"), k) || strings.Contains(info.GetString("type"), k) {
+						info["type"] = v1
+					}
+				}
+
+				coloum = Map{
+					"name":  info.GetString("name"),
+					"type":  info.GetString("type"),
+					"label": info.GetString("label"),
+					//"add":   false, "info": false, "edit": false, "list": true,
+					//"must": false,
+				}
+
+				//备注以空格隔开，空格后的是其他备注
+				indexNum := strings.Index(info.GetString("label"), " ")
+				if indexNum > -1 {
+					coloum["label"] = info.GetString("label")[:indexNum]
+				}
+				//去除数据信息，是用：号分割的
+				indexNum = strings.Index(coloum.GetString("label"), ":")
+				if indexNum > -1 {
+					coloum["label"] = coloum.GetString("label")[:indexNum]
+				}
+
+				for _, ColumnName := range ColumnNameType {
+					if (ColumnName.Strict && coloum.GetString("name") == ColumnName.Name) ||
+						(!ColumnName.Strict && strings.Contains(coloum.GetString("name"), ColumnName.Name)) {
+						//全部都不需要则不加入
+						if ColumnName.Edit == false && ColumnName.List == false && ColumnName.Info == false {
+							coloum["notUse"] = true
+							//continue
+						}
+						coloum["info"] = ColumnName.Info
+						coloum["edit"] = ColumnName.Edit
+						coloum["add"] = ColumnName.Edit
+						coloum["list"] = ColumnName.List
+						coloum["must"] = ColumnName.Must
+
+						if ColumnName.Info {
+							delete(coloum, "info")
+						}
+						if ColumnName.Edit {
+							delete(coloum, "edit")
+							delete(coloum, "add")
+						}
+						if ColumnName.List {
+							delete(coloum, "list")
+						}
+						if ColumnName.Must {
+							delete(coloum, "must")
+						}
+
+						if ColumnName.Type != "" {
+							coloum["type"] = ColumnName.Type
+						}
+						if ColumnName.Strict && coloum.GetString("name") == ColumnName.Name {
+							break
+						}
+
+					}
+				}
+
+				//如果是select类型需要设置options
+				if coloum.GetString("type") == "number" {
+					coloum["sortable"] = true
+				}
+
+				//if !coloum.GetBool("notUse") {
+				that.TableConfig.GetMap(v.GetString("name"))["columns"] = append(that.TableConfig.GetMap(v.GetString("name")).GetSlice("columns"), coloum)
+				//}
+				//如果是select类型需要设置options
+				//if coloum.GetString("type") == "select" {
+
+				options := Slice{}
+				comments := strings.Split(info.GetString("label"), ":")
+				if len(comments) >= 2 {
+					optionComment := strings.Split(comments[1], ",")
+					for _, v := range optionComment {
+						optionSlice := strings.Split(v, "-")
+						if len(optionSlice) >= 2 {
+							options = append(options, Map{"name": optionSlice[1], "value": optionSlice[0]})
+						}
+					}
+				}
+
+				if coloum.GetString("type") == "select" {
+					coloum["must"] = true
+					coloum["options"] = options
+				} else if len(options) > 0 {
+					coloum["must"] = true
+					coloum["options"] = options
+					coloum["type"] = "select"
+
+				}
+				//}
+
+			}
+			//else {
+			//
+			//	//if !(coloum.GetString("label") != "备注" && info.GetString("label") == "备注") {
+			//	//	coloum["label"] = info.GetString("label")
+			//	//}
+			//	//coloum["type"] = info.GetString("type")
+			//}
+
+			//暂时不关闭参数，保证表数据完全读取到
+			that.TableColumns[v.GetString("name")][info.GetString("name")] = coloum
+
+		}
+
+		if makeCode {
+			//创建模块文件
+			//判断文件是否存在
+			//_, err := os.OpenFile(name+"/"+v.GetString("name"), os.O_RDONLY, os.ModePerm)
+			_, err := os.Stat(name + "/" + v.GetString("name") + ".go")
+			if err != nil { //文件不存在，则根据模板创建
+				myCtr := strings.Replace(CtrTpt, "{{name}}", name, -1)
+				myCtr = strings.Replace(myCtr, "{{table}}", v.GetString("name"), -1)
+				_ = os.MkdirAll(name, os.ModeDir)
+				err = ioutil.WriteFile(name+"/"+v.GetString("name")+".go", []byte(myCtr), os.ModePerm)
+				if err != nil {
+					that.Error.SetError(err)
+				}
+				isMake = true
+			}
+
+			ctrList = ctrList + `"` + v.GetString("name") + `":` + v.GetString("name") + "Ctr,\r\n    "
+
+		}
+
+	}
+
+	that.Config["tables"] = that.TableConfig
+
+	//生成id，判断数据库是否有改变，以保证数据库和配置文件匹配唯一
+	id := Md5(ObjToStr(idSlice))
+	if id == that.Config.GetString("id") {
+		if isMake { //有生成包文件
+			fmt.Println("有新的业务代码生成，请重新运行")
+			os.Exit(-1)
+		}
+		return
+	}
+	//数据生成完后进一步解析
+	for fk, fv := range that.TableColumns {
+
+		//判断是否将表写入menu中
+		isMenusGet := false //判断是否被目录收录
+		for indexKey, _ := range that.IndexMenus {
+			indexCode := strings.Index(indexKey, fk)
+			if indexCode == 0 || indexCode == 4 {
+				isMenusGet = false
+				continue
+			}
+			//如果相等或者表名在目录中已经设置（主要前一位是/并且他是最后一个字符串）
+			if indexKey == fk || (indexCode != -1 && indexKey[indexCode-1] == '/' && indexKey[indexCode:] == fk) {
+				isMenusGet = true
+				break
+			}
+		}
+
+		//目录没有收录
+		if !isMenusGet {
+
+			tablePrefixCode := strings.Index(fk, "_")
+			isNewPrefix := false //假定表名没有前缀
+			prefixName := ""
+			//并且代表有前缀，根据数据表分库设定使用
+			if tablePrefixCode != -1 {
+				prefixName = fk[:tablePrefixCode]
+			} else {
+				prefixName = fk
+			}
+			//if tablePrefixCode != -1 {
+			for ck, _ := range that.TableColumns {
+				//判断不止一个前缀相同
+				if (strings.Index(ck, prefixName) == 0 || strings.Index(prefixName, ck) == 4) && ck != fk {
+					isNewPrefix = true
+					break
+				}
+			}
+			//}
+
+			prefixName = DefaultMenuParentName + ":" + prefixName
+
+			menuIns := Map{"label": that.TableConfig.GetMap(fk).GetString("label"), "table": fk}
+			//多耗费一点内存
+			mMenu := Map{"menus": Slice{menuIns}, "label": that.TableConfig.GetMap(fk).GetString("label"), "name": prefixName, "icon": "el-icon-setting"}
+			//表名有前缀
+			if !isNewPrefix {
+				//是否已有对应前缀，已经有对应的menu只需要push进去即可
+				prefixName = DefaultMenuParentName
+				mMenu = Map{"menus": Slice{menuIns}, "label": "系统管理", "name": prefixName, "icon": "el-icon-setting"}
+			}
+			//没有新前缀
+			if that.IndexMenus[prefixName] != nil {
+				if that.IndexMenus[prefixName+"/"+fk] == nil {
+					that.IndexMenus.GetMap(prefixName)["menus"] = append(that.IndexMenus.GetMap(prefixName).GetSlice("menus"), menuIns)
+					that.IndexMenus[prefixName+"/"+fk] = menuIns
+				} else {
+					for k, v := range menuIns {
+						that.IndexMenus.GetMap(prefixName + "/" + fk)[k] = v
+					}
+				}
+
+			} else {
+
+				that.Config["menus"] = append(that.Config.GetSlice("menus"), mMenu) //注入配置
+				//写入Index
+				that.IndexMenus[prefixName] = mMenu
+				that.IndexMenus[prefixName+"/"+fk] = menuIns
+			}
+		}
+
+		for k, v := range fv {
+
+			//搜索服务
+			if that.SearchColumns[fk][v.GetString("name")] == nil &&
+				v.GetString("type") == "select" {
+				search := that.TableConfig.GetMap(fk).GetSlice("search")
+				sv := DeepCopyMap(v).(Map)
+				sv["value"] = nil
+				sv["options"] = append(sv.GetSlice("options"), Map{"name": "全部", "value": nil})
+				that.TableConfig.GetMap(fk)["search"] = append(search, sv)
+				that.SearchColumns[fk][k] = sv
+			}
+
+			//虚招后缀是_id结尾的表字段 假设org_id
+			if len(k) <= 3 || strings.LastIndex(k, "_id") != len(k)-3 {
+				continue
+			}
+			//普通表匹配 org_id匹配为org
+			oldTableName := k[:len(k)-3]
+			//上级ID匹配
+			if oldTableName == "parent" {
+				oldTableName = fk
+			}
+			//如果本身匹配则不再继续精简匹配
+			if that.TableConfig[oldTableName] == nil {
+
+				//如果依然找不到则查询system_org是否存在
+				if that.TableConfig[DefaultMenuParentName+"_"+oldTableName] != nil {
+					oldTableName = DefaultMenuParentName + "_" + oldTableName
+				}
+
+				//字段有动词前缀，自动进行解析
+				prefixColumn := strings.Index(oldTableName, "_")
+
+				//sys_org_id oldTableName即为sys此处判断为org表存在
+
+				if prefixColumn > -1 && that.TableConfig[oldTableName[prefixColumn+1:]] != nil {
+					oldTableName = oldTableName[prefixColumn+1:]
+				}
+				if prefixColumn >= len(oldTableName) {
+					prefixColumn = -1
+				}
+				//如果依然找不到则查询system_org是否存在
+				if prefixColumn > -1 && that.TableConfig[DefaultMenuParentName+"_"+oldTableName[prefixColumn+1:]] != nil {
+					oldTableName = DefaultMenuParentName + "_" + oldTableName[prefixColumn+1:]
+				}
+			}
+
+			//普通方式查询不到，则转换为大型项目模块划分,暂时只支持一级模块划分，
+			//比如表sys_user 字段org_id，查询不到sys_org表则查询org表，org表查询不到则查询默认前缀system_org表
+			//都查询不到则找不到，
+			prefix := strings.Index(fk, "_")
+			tableName := oldTableName
+			if prefix > 0 {
+				//表模块前缀sys_user sys即为前缀 sys_org
+				tableName = fk[:prefix+1] + oldTableName
+				if that.TableConfig[tableName] == nil || that.TableConfig[oldTableName] != nil {
+					//不存在则改为org
+					tableName = oldTableName
+				}
+				//表前缀+去除字段前缀
+				prefixColumn := strings.Index(oldTableName, "_")
+				if prefixColumn > -1 {
+					tableName = fk[:prefix+1] + oldTableName[prefixColumn+1:]
+					if that.TableConfig[tableName] == nil {
+						tableName = oldTableName
+					}
+				}
+			}
+
+			//如果数据匹配则写入到配置中
+			if that.TableConfig[tableName] != nil {
+				v["link"] = tableName
+				//一般查询name字段或者label字段，如果没有name字段则默认第二个地段
+				if that.TableColumns[tableName]["name"] != nil {
+					v["value"] = "name"
+					continue
+				}
+				if that.TableColumns[tableName]["label"] != nil {
+					v["value"] = "label"
+					continue
+				}
+
+				if len(that.TableConfig.GetMap(tableName).GetSlice("columns")) > 2 {
+					v["value"] = that.TableConfig.GetMap(tableName).GetSlice("columns").GetMap(1).GetString("name")
+					continue
+				}
+
+			}
+
+		}
+	}
+
+	//搜索增加树节点
+	for fk, fv := range that.TableColumns {
+		for k, v := range fv {
+			if v.GetString("link") != "" && that.SearchColumns[fk][k] == nil &&
+				that.TableColumns[v.GetString("link")]["parent_id"] != nil {
+				//搜索服务
+				search := that.TableConfig.GetMap(fk).GetSlice("search")
+				sv := Map{"type": "tree", "label": v["label"], "name": v["name"], "value": v["value"], "link": v["link"]}
+				that.TableConfig.GetMap(fk)["search"] = append(search, sv)
+
+				that.SearchColumns[fk][k] = sv
+			}
+		}
+	}
+
+	fmt.Println(id, "---", that.Config.GetString("id"))
+	that.Config["id"] = id
+
+	if makeCode {
+		//init文件初始化
+		myInit = strings.Replace(myInit, "{{id}}", id, -1)
+		myInit = strings.Replace(myInit, "{{tablesCtr}}", ctrList, -1)
+		_ = os.MkdirAll(name, os.ModeDir)
+		err = ioutil.WriteFile(name+"/init.go", []byte(myInit), os.ModePerm)
+		if err != nil {
+			that.Error.SetError(err)
+		}
+	}
+	//写入配置文件
+	//var configByte bytes.Buffer
+
+	//err = json.Indent(&configByte, []byte(that.Config.ToJsonString()), "", "\t")
+	_ = os.MkdirAll(filepath.Dir(path), os.ModeDir)
+	err = ioutil.WriteFile(path, []byte(that.Config.ToJsonString()), os.ModePerm)
+	if err != nil {
+		that.Error.SetError(err)
+	}
+	fmt.Println("有新的代码生成，请重新运行")
+	os.Exit(-1)
+
+}
+
+func (that *MakeCode) Info(table string, userData Map, db *db.HoTimeDB) (string, Map) {
+	reStr := ""
+	data := Map{}
+	var ruleData Map
+	for _, v := range that.TableColumns[table] {
+		if v == nil {
+			continue
+		}
+		//准备加入索引权限
+		if v.GetString("link") != "" &&
+			userData != nil &&
+			that.TableColumns[v.GetString("link")]["parent_id"] != nil {
+			//初始化ruleData
+			if ruleData == nil {
+				ruleData = Map{}
+				for _, v := range that.TableColumns["admin"] {
+					if v.GetString("link") != "" &&
+						v.GetString("name") != "parent_id" &&
+						userData.Get(v.GetString("name")) != nil {
+						ruleData[v.GetString("link")] = userData.Get(v.GetString("name"))
+					}
+				}
+			}
+			if ruleData[v.GetString("link")] != nil {
+
+				if v.GetString("name") == "parent_id" {
+					data["index[~]"] = "," + ruleData.GetString(v.GetString("link")) + ","
+
+				} else {
+					idMap := db.Select(v.GetString("link"), "id", Map{"index[~]": "," + ruleData.GetString(v.GetString("link")) + ","})
+					ids := Slice{ruleData.GetCeilInt(v.GetString("link"))}
+					for _, v := range idMap {
+						ids = append(ids, v.GetCeilInt("id"))
+					}
+					data[v.GetString("name")] = ids
+				}
+
+			}
+		}
+
+		if v.Get("info") == nil || v.GetBool("info") {
+			reStr += "`" + v.GetString("name") + "`,"
+		}
+	}
+	if len(reStr) != 0 {
+		reStr = reStr[:len(reStr)-1]
+	}
+	return reStr, data
+}
+func (that *MakeCode) Add(table string, req *http.Request) Map {
+	data := Map{}
+	for _, v := range that.TableColumns[table] {
+		//不可使用，未在前端展示，但在内存中保持有
+		if v.GetBool("notUse") {
+			if v.GetString("type") == "index" && that.TableColumns[table]["parent_id"] != nil {
+				data[v.GetString("name")] = ","
+			}
+
+			continue
+		}
+		if v.Get("add") == nil || v.GetBool("add") {
+
+			if len(req.Form[v.GetString("name")]) == 0 {
+				if v.GetBool("must") {
+					return nil
+				} else {
+					continue
+				}
+
+			}
+			reqValue := req.FormValue(v.GetString("name"))
+			if (reqValue == "" || reqValue == "null") && strings.Contains(v.GetString("name"), "id") {
+				data[v.GetString("name")] = nil
+			} else {
+				if v.GetString("type") == "password" {
+					data[v.GetString("name")] = Md5(reqValue)
+				} else {
+					data[v.GetString("name")] = reqValue
+				}
+
+			}
+		}
+
+		if v.GetString("name") == "create_time" {
+			data[v.GetString("name")] = time.Now().Unix()
+			continue
+		}
+
+		if v.GetString("name") == "modify_time" {
+			data[v.GetString("name")] = time.Now().Unix()
+		}
+	}
+	if len(data) == 0 {
+		return nil
+	}
+
+	return data
+}
+func (that *MakeCode) Edit(table string, req *http.Request) Map {
+	data := Map{}
+	for _, v := range that.TableColumns[table] {
+		//不可使用，未在前端展示，但在内存中保持有
+		if v.GetBool("notUse") {
+			if v.GetString("type") == "index" && that.TableColumns[table]["parent_id"] != nil {
+				data[v.GetString("name")] = ","
+			}
+			continue
+		}
+
+		if v.Get("edit") == nil || v.GetBool("edit") {
+			reqValue := req.FormValue(v.GetString("name"))
+			if reqValue == "" || reqValue == "null" {
+				continue
+			}
+			if v.GetString("type") == "password" {
+				data[v.GetString("name")] = Md5(reqValue)
+			} else {
+				data[v.GetString("name")] = reqValue
+			}
+		}
+		if v.GetString("name") == "modify_time" {
+			data[v.GetString("name")] = time.Now().Unix()
+		}
+	}
+
+	if len(data) == 0 {
+		return nil
+	}
+
+	return data
+}
+func (that *MakeCode) Delete(table string, req *http.Request) Map {
+	data := Map{}
+	for _, v := range that.TableColumns[table] {
+		//不可使用，未在前端展示，但在内存中保持有
+		if v.GetBool("notUse") {
+			if v.GetString("type") == "index" && that.TableColumns[table]["parent_id"] != nil {
+				data[v.GetString("name")] = ","
+			}
+			continue
+		}
+
+	}
+	return data
+}
+
+func (that *MakeCode) Search(table string, userData Map, req *http.Request, db *db.HoTimeDB) (string, Map, Map) {
+	reStr := ""
+	leftJoin := Map{}
+	data := Map{}
+	keyword := Map{}
+	daterange := Map{}
+	sort := Map{}
+	var ruleData Map
+	hasUser := false
+
+	keywordStr := req.FormValue("keyword")
+	for _, v := range that.TableColumns[table] {
+		//不可使用，未在前端展示，但在内存中保持有
+		if v.GetBool("notUse") {
+
+			continue
+		}
+		if v["list"] != false {
+
+			if v.GetString("link") != "" &&
+				v.GetString("name") != "parent_id" {
+
+				reStr += table + "." + v.GetString("name") + "," +
+					v.GetString("link") + "." + v.GetString("value") + " AS " +
+					v.GetString("link") + "_" + v.GetString("name") + "_" + v.GetString("value") + ","
+
+				leftJoin["[>]"+v.GetString("link")] =
+					table + "." + v.GetString("name") + "=" +
+						v.GetString("link") + ".id"
+				if v.GetString("link") == "admin" {
+					hasUser = true
+				}
+
+				reqValue := req.FormValue(v.GetString("name"))
+				if reqValue != "" {
+					data[table+"."+v.GetString("name")] = reqValue
+				}
+
+			} else {
+				reStr += table + "." + v.GetString("name") + ","
+			}
+
+			//准备加入索引权限
+			if v.GetString("link") != "" &&
+				userData != nil &&
+				that.TableColumns[v.GetString("link")]["parent_id"] != nil {
+				//初始化ruleData
+				if ruleData == nil {
+					ruleData = Map{}
+					for _, v := range that.TableColumns["admin"] {
+						if v.GetString("link") != "" &&
+							v.GetString("name") != "parent_id" &&
+							userData.Get(v.GetString("name")) != nil {
+							ruleData[v.GetString("link")] = userData.Get(v.GetString("name"))
+						}
+					}
+				}
+				if ruleData[v.GetString("link")] != nil {
+
+					if v.GetString("name") == "parent_id" {
+						data[table+".index[~]"] = "," + ruleData.GetString(v.GetString("link")) + ","
+
+					} else {
+						idMap := db.Select(v.GetString("link"), "id", Map{"index[~]": "," + ruleData.GetString(v.GetString("link")) + ","})
+						ids := Slice{ruleData.GetCeilInt(v.GetString("link"))}
+						for _, v := range idMap {
+							ids = append(ids, v.GetCeilInt("id"))
+						}
+						data[table+"."+v.GetString("name")] = ids
+					}
+
+				}
+
+			}
+
+			if keywordStr != "" {
+				if v.GetString("type") == "text" {
+					keyword[table+"."+v.GetString("name")+"[~]"] = keywordStr
+
+				}
+				if v.GetString("name") == "id" {
+					keyword[table+"."+v.GetString("name")] = keywordStr
+				}
+				if v.GetString("link") != "" &&
+					v.GetString("name") != "parent_id" {
+					childs := db.Select(v.GetString("link"), "id", Map{v.GetString("value") + "[~]": keywordStr})
+					childIds := Slice{}
+					for _, cv := range childs {
+						childIds = append(childIds, cv.GetString("id"))
+					}
+					if len(childIds) != 0 {
+						keyword[v.GetString("link")+".id"] = childIds
+					}
+
+				}
+			}
+
+		}
+	}
+	if len(reStr) != 0 {
+		reStr = reStr[:len(reStr)-1]
+	}
+
+	search := that.TableConfig.GetMap(table).GetSlice("search")
+	for k, _ := range search {
+
+		reqValue := req.FormValue(search.GetMap(k).GetString("name"))
+		if reqValue == "" {
+			continue
+		}
+		searchItem := search.GetMap(k)
+		searchItemName := searchItem.GetString("name")
+
+		//columns := that.TableConfig.GetMap(table).GetSlice("columns")
+		if searchItem.GetString("type") == "search" {
+			for _, v := range that.TableColumns[table] {
+				if v["list"] == false {
+					continue
+				}
+				//日期类型
+				if searchItemName == "daterange" && v.GetString("type") == "time" {
+					//fmt.Println(req.Form["daterange"])
+					daterange[table+"."+v.GetString("name")+"[<>]"] = ObjToSlice(req.Form["daterange"])
+				}
+			}
+
+			if searchItem.GetString("name") == "sort" {
+				sort["ORDER"] = table + "." + reqValue
+			}
+
+			continue
+		}
+		//树节点模式搜索
+		if searchItemName == "parent_id" {
+			parentID := ObjToInt(req.FormValue("parent_id"))
+			if parentID == 0 {
+				parentID = userData.GetCeilInt(table + "_id")
+				data["OR"] = Map{table + ".id": parentID, table + ".parent_id": nil}
+			} else {
+				data[table+".parent_id"] = parentID
+			}
+			continue
+		}
+
+		data[table+"."+searchItemName] = reqValue
+
+	}
+	if sort["ORDER"] == nil {
+		sort["ORDER"] = table + ".id DESC"
+	}
+
+	where := Map{}
+
+	if len(keyword) == 1 {
+		for k, v := range keyword {
+			data[k] = v
+		}
+	}
+	if len(keyword) > 1 {
+		if data["OR"] != nil {
+			data = Map{"AND": data, "OR": keyword}
+		} else {
+			data["OR"] = keyword
+		}
+
+	}
+
+	if len(daterange) == 1 {
+		for k, v := range daterange {
+			data[k] = v
+		}
+	}
+
+	if len(daterange) > 1 {
+		if data["AND"] != nil {
+			data = Map{"AND": Map{"AND": data, "OR": daterange}}
+		}
+	}
+
+	if len(data) > 1 {
+		where["AND"] = data
+	}
+
+	if len(data) == 1 {
+		where = data
+	}
+
+	if len(where) == 0 && hasUser {
+
+		//where["admin.id"] = userData["id"]
+
+	}
+
+	if len(sort) != 0 {
+		for k, v := range sort {
+			where[k] = v
+		}
+	}
+
+	return reStr, leftJoin, where
+}
+
+func setListener() {
+
+}

code/template.go

@@ -0,0 +1,230 @@
+package code
+
+var InitTpt = `package {{name}}
+
+import (
+	. "../../../hotime"
+	. "../../../hotime/common"
+)
+
+var ID = "{{id}}"
+
+// Project 管理端项目
+var Project = Proj{
+	//"user": UserCtr,
+	{{tablesCtr}}
+    "hotime":Ctr{
+		"login": func(this *Context) {
+			name := this.Req.FormValue("name")
+			password := this.Req.FormValue("password")
+			if name == "" || password == "" {
+				this.Display(3, "参数不足")
+				return
+			}
+			user := this.Db.Get("admin", "*", Map{"AND": Map{"OR":Map{"name": name,"phone":name}, "password": Md5(password)}})
+			if user == nil {
+				this.Display(5, "登录失败")
+				return
+			}
+			this.Session("admin_id", user.GetCeilInt("id"))
+			this.Session("admin_name", name)
+			this.Display(0, this.SessionId)
+		},
+		"logout": func(this *Context) {
+			this.Session("admin_id", nil)
+			this.Session("admin_name", nil)
+			this.Display(0, "退出登录成功")
+		},
+		"info": func(that *Context) {
+			data := that.Db.Get("admin", "*", Map{"id": that.Session("admin_id").ToCeilInt()})
+			str, inData := that.MakeCode.Info("admin", data, that.Db)
+			where := Map{"id": that.Session("admin_id").ToCeilInt()}
+			if len(inData) ==1 {
+				inData["id"] =where["id"]
+				where = Map{"AND": inData}
+			}else if len(inData) >1 {
+				where["OR"]=inData
+				where = Map{"AND": where}
+			}
+			re := that.Db.Get("admin", str, where)
+			if re == nil {
+				that.Display(4, "找不到对应信息")
+				return
+			}
+			for k, v := range re {
+				column := that.MakeCode.TableColumns["admin"][k]
+				if column == nil {
+					continue
+				}
+				if (column["list"] == nil || column.GetBool("list")) && column.GetString("link") != "" {
+					re[column.GetString("link")] = that.Db.Get(column.GetString("link"),"id," +column.GetString("value"), Map{"id": v})
+				}
+			}
+
+			that.Display(0, re)
+		},
+	},
+}
+`
+var CtrTpt = `package {{name}}
+
+import (
+	. "../../../hotime"
+	. "../../../hotime/common"
+	"strings"
+)
+
+var {{table}}Ctr = Ctr{
+	"info": func(that *Context) {
+		data := that.Db.Get("admin", "*", Map{"id": that.Session("admin_id").ToCeilInt()})
+		str, inData := that.MakeCode.Info(that.RouterString[1], data, that.Db)
+		where := Map{"id": that.RouterString[2]}
+
+		if len(inData) ==1 {
+			inData["id"] =where["id"]
+			where = Map{"AND": inData}
+		}else if len(inData) >1 {
+			where["OR"]=inData
+			where = Map{"AND": where}
+		}
+
+		re := that.Db.Get(that.RouterString[1], str, where)
+
+		if re == nil {
+			that.Display(4, "找不到对应信息")
+			return
+		}
+
+		for k, v := range re {
+			column := that.MakeCode.TableColumns[that.RouterString[1]][k]
+			if column == nil {
+				continue
+			}
+			if (column["list"] == nil || column.GetBool("list")) && column.GetString("link") != "" {
+				re[column.GetString("link")] = that.Db.Get(column.GetString("link"), "id,"+column.GetString("value"), Map{"id": v})
+			}
+		}
+
+		that.Display(0, re)
+	},
+	"add": func(that *Context) {
+		inData := that.MakeCode.Add(that.RouterString[1], that.Req)
+		if inData == nil {
+			that.Display(3, "请求参数不足")
+			return
+		}
+
+
+		re := that.Db.Insert(that.RouterString[1], inData)
+
+		if re == 0 {
+			that.Display(4, "无法插入对应数据")
+			return
+		}
+		//索引管理，便于检索以及权限
+		if inData.Get("parent_id") != nil && inData.GetString("index") != "" {
+			index := that.Db.Get(that.RouterString[1], "` + "`index`" + `", Map{"id": inData.Get("parent_id")})
+			inData["index"] = index.GetString("index")+ObjToStr(re)+","
+			that.Db.Update(that.RouterString[1],Map{"index":inData["index"]},Map{"id":re})
+		}else if inData.GetString("index") != ""{
+			inData["index"] = "," + ObjToStr(re) + ","
+			that.Db.Update(that.RouterString[1], Map{"index": inData["index"]}, Map{"id": re})
+		}
+
+		that.Display(0, re)
+	},
+	"update": func(that *Context) {
+		inData := that.MakeCode.Edit(that.RouterString[1], that.Req)
+		if inData == nil {
+			that.Display(3, "没有找到要更新的数据")
+			return
+		}
+
+		//索引管理，便于检索以及权限
+		if inData.Get("parent_id") != nil && inData.GetString("index") != "" {
+			Index := that.Db.Get(that.RouterString[1], "` + "`index`" + `", Map{"id": that.RouterString[2]})
+			parentIndex := that.Db.Get(that.RouterString[1], "` + "`index`" + `", Map{"id": inData.Get("parent_id")})
+			inData["index"] = parentIndex.GetString("index") + that.RouterString[2] + ","
+
+			childNodes := that.Db.Select(that.RouterString[1], "id,` + "`index`" + `", Map{"index[~]": "," + that.RouterString[2] + ","})
+
+			for _, v := range childNodes {
+				v["index"] = strings.Replace(v.GetString("index"), Index.GetString("index"), inData.GetString("index"), -1)
+				that.Db.Update(that.RouterString[1], Map{"index": v["index"]}, Map{"id": v.GetCeilInt("id")})
+			}
+
+		}
+
+		re := that.Db.Update(that.RouterString[1], inData, Map{"id": that.RouterString[2]})
+
+		if re == 0 {
+			that.Display(4, "更新数据失败")
+			return
+		}
+
+		that.Display(0, re)
+	},
+	"remove": func(that *Context) {
+		inData := that.MakeCode.Delete(that.RouterString[1], that.Req)
+		if inData == nil {
+			that.Display(3, "请求参数不足")
+			return
+		}
+		re :=int64(0)
+		//索引管理，便于检索以及权限
+		if inData.Get("parent_id") != nil && inData.GetSlice("index") != nil {
+			re=that.Db.Delete(that.RouterString[1], Map{"index[~]": "," + that.RouterString[2] + ","})
+		}else {
+			re=that.Db.Delete(that.RouterString[1], Map{"id": that.RouterString[2]})
+		}
+
+		if re == 0 {
+			that.Display(4, "删除数据失败")
+			return
+		}
+		that.Display(0, "删除成功")
+	},
+
+	"search": func(that *Context) {
+
+		data := that.Db.Get("admin", "*", Map{"id": that.Session("admin_id").ToCeilInt()})
+
+		columnStr, leftJoin, where := that.MakeCode.Search(that.RouterString[1], data, that.Req, that.Db)
+
+		page := ObjToInt(that.Req.FormValue("page"))
+		pageSize := ObjToInt(that.Req.FormValue("pageSize"))
+
+		if page < 1 {
+			page = 1
+		}
+
+		if pageSize <= 0 {
+			pageSize = 20
+		}
+
+		count := that.Db.Count(that.RouterString[1], leftJoin, where)
+		reData := that.Db.Page(page, pageSize).
+			PageSelect(that.RouterString[1], leftJoin, columnStr, where)
+
+		for _, v := range reData {
+			for k, _ := range v {
+				column := that.MakeCode.TableColumns[that.RouterString[1]][k]
+				if column == nil {
+					continue
+				}
+
+				if column["list"] != false && column["name"] == "parent_id" && column.GetString("link") != "" {
+					parentC := that.Db.Get(column.GetString("link"), column.GetString("value"), Map{"id": v.GetCeilInt(k)})
+					v[column.GetString("link")+"_"+column.GetString("name")+"_"+column.GetString("value")] = ""
+					if parentC != nil {
+						v[column.GetString("link")+"_"+column.GetString("name")+"_"+column.GetString("value")] = parentC.GetString(column.GetString("value"))
+					}
+				}
+
+			}
+		}
+
+		that.Display(0, Map{"count": count, "data": reData})
+	},
+}
+`

common/context_base.go

@@ -0,0 +1,18 @@
+package common
+
+import (
+	"time"
+)
+
+type ContextBase struct {
+	tag string
+}
+
+//唯一标志
+func (this *ContextBase) GetTag() string {
+
+	if this.tag == "" {
+		this.tag = ObjToStr(time.Now().Unix()) + ":" + ObjToStr(Random())
+	}
+	return this.tag
+}

common/error.go

@@ -0,0 +1,27 @@
+package common
+
+import (
+	"github.com/sirupsen/logrus"
+)
+
+// Error 框架层处理错误
+type Error struct {
+	Logger *logrus.Logger
+	error
+}
+
+func (that *Error) GetError() error {
+
+	return that.error
+
+}
+
+func (that *Error) SetError(err error) {
+	that.error = err
+	if that.Logger != nil && err != nil {
+		//that.Logger=log.GetLog("",false)
+		that.Logger.Warn(err)
+	}
+
+	return
+}

common/func.go

@@ -1,15 +1,10 @@
-package hotime
+package common
 
 import (
 	"crypto/md5"
 	"encoding/hex"
-	"fmt"
 	"math"
-	"os"
-	"path/filepath"
-	"runtime"
 	"strings"
-	"time"
 )
 
 //安全锁
@@ -29,83 +24,7 @@ import (
 //	return res
 //}
 
-func LogError(logMsg interface{}) {
-
-	logFmt(fmt.Sprintln(logMsg), 2, LOG_ERROR)
-}
-func LogWarn(logMsg interface{}) {
-
-	logFmt(fmt.Sprintln(logMsg), 2, LOG_WARN)
-}
-func LogInfo(logMsg ...interface{}) {
-
-	logFmt(fmt.Sprintln(logMsg), 2, LOG_INFO)
-}
-
-//func LogFmt(logMsg interface{}, loglevel ...LOG_MODE) {
-//
-//	logFmt(logMsg, 2, loglevel...)
-//}
-
-//日志打印以及存储到文件
-func logFmt(logMsg interface{}, printLevel int, loglevel ...LOG_MODE) {
-
-	if Config.GetInt("logLevel") == int(LOG_NIL) {
-		return
-	}
-
-	lev := LOG_INFO
-	if len(loglevel) != 0 {
-		lev = loglevel[0]
-	}
-	gofile := ""
-
-	if Config.GetInt("debug") != 0 && printLevel != 0 {
-		_, file, line, ok := runtime.Caller(printLevel)
-		if ok {
-			gofile = " " + file + ":" + ObjToStr(line)
-		}
-	}
-
-	logStr := ""
-
-	if lev == LOG_INFO {
-		logStr = "info:"
-	}
-	if printLevel == 0 {
-		logStr = "connect:"
-	}
-
-	if lev == LOG_WARN {
-		logStr = "warn:"
-	}
-
-	if lev == LOG_ERROR {
-		logStr = "error:"
-	}
-
-	logStr = fmt.Sprintln(time.Now().Format("2006/01/02 15:04:05"), logStr, logMsg, gofile)
-	//打印日志
-	fmt.Print(logStr)
-	//不需要存储到文件
-	if Config.GetString("logFile") == "" {
-		return
-	}
-	//存储到文件
-	logFilePath := time.Now().Format(Config.GetString("logFile"))
-
-	os.MkdirAll(filepath.Dir(logFilePath), os.ModeAppend)
-	//os.Create(logFilePath)
-	f, err := os.OpenFile(logFilePath, os.O_APPEND|os.O_CREATE, 0644)
-	if err != nil {
-		return
-	}
-	f.Write([]byte(logStr))
-	f.Close()
-
-}
-
-//字符串首字符大写
+// StrFirstToUpper 字符串首字符大写
 func StrFirstToUpper(str string) string {
 	if len(str) == 0 {
 		return str
@@ -117,7 +36,43 @@ func StrFirstToUpper(str string) string {
 	return strings.ToUpper(first) + other
 }
 
-//字符串截取
+//相似度计算 ld compares two strings and returns the levenshtein distance between them.
+func StrLd(s, t string, ignoreCase bool) int {
+	if ignoreCase {
+		s = strings.ToLower(s)
+		t = strings.ToLower(t)
+	}
+	d := make([][]int, len(s)+1)
+	for i := range d {
+		d[i] = make([]int, len(t)+1)
+	}
+	for i := range d {
+		d[i][0] = i
+	}
+	for j := range d[0] {
+		d[0][j] = j
+	}
+	for j := 1; j <= len(t); j++ {
+		for i := 1; i <= len(s); i++ {
+			if s[i-1] == t[j-1] {
+				d[i][j] = d[i-1][j-1]
+			} else {
+				min := d[i-1][j]
+				if d[i][j-1] < min {
+					min = d[i][j-1]
+				}
+				if d[i-1][j-1] < min {
+					min = d[i-1][j-1]
+				}
+				d[i][j] = min + 1
+			}
+		}
+
+	}
+	return d[len(s)][len(t)]
+}
+
+// Substr 字符串截取
 func Substr(str string, start int, length int) string {
 	rs := []rune(str)
 	rl := len(rs)
@@ -148,7 +103,7 @@ func Substr(str string, start int, length int) string {
 	return string(rs[start:end])
 }
 
-//获取最后出现字符串的下标
+// IndexLastStr 获取最后出现字符串的下标
 //return  找不到返回 -1
 func IndexLastStr(str, sep string) int {
 	sepSlice := []rune(sep)
@@ -179,7 +134,7 @@ func IndexLastStr(str, sep string) int {
 	return -1
 }
 
-//md5
+// Md5 md5
 func Md5(req string) string {
 	md5Ctx := md5.New()
 	md5Ctx.Write([]byte(req))

common/map.go

@@ -1,4 +1,4 @@
-package hotime
+package common
 
 import (
 	"encoding/json"
@@ -90,6 +90,14 @@ func (this Map) GetSlice(key string, err ...*Error) Slice {
 
 	return v
 
+}
+func (this Map) GetBool(key string, err ...*Error) bool {
+
+	//var v Slice
+	v := ObjToBool((this)[key], err...)
+
+	return v
+
 }
 
 func (this Map) GetMap(key string, err ...*Error) Map {

common/obj.go

@@ -0,0 +1,94 @@
+package common
+
+//对象封装方便取用
+type Obj struct {
+	Data interface{}
+	Error
+	ContextBase
+}
+
+func (that *Obj) Put(data interface{}) {
+	that.Data = data
+}
+
+func (that *Obj) ToInt(err ...Error) int {
+	if len(err) != 0 {
+		that.Error = err[0]
+	}
+	return ObjToInt(that.Data, &that.Error)
+}
+
+func (that *Obj) ToInt64(err ...Error) int64 {
+	if len(err) != 0 {
+		that.Error = err[0]
+	}
+	return ObjToInt64(that.Data, &that.Error)
+}
+
+func (that *Obj) ToFloat64(err ...Error) float64 {
+	if len(err) != 0 {
+		that.Error = err[0]
+	}
+	return ObjToFloat64(that.Data, &that.Error)
+}
+
+// ToCeilFloat64 获取向上取整float64
+func (that *Obj) ToCeilFloat64(err ...*Error) float64 {
+	if len(err) != 0 {
+		that.Error = *err[0]
+	}
+	v := ObjToCeilFloat64(that.Data, err...)
+	return v
+
+}
+
+func (that *Obj) ToStr() string {
+
+	return ObjToStr(that.Data)
+}
+
+func (that *Obj) ToMap(err ...Error) Map {
+	if len(err) != 0 {
+		that.Error = err[0]
+	}
+	return ObjToMap(that.Data, &that.Error)
+}
+
+func (that *Obj) ToSlice(err ...Error) Slice {
+	if len(err) != 0 {
+		that.Error = err[0]
+	}
+	return ObjToSlice(that.Data, &that.Error)
+}
+
+func (that *Obj) ToMapArray(err ...Error) []Map {
+	if len(err) != 0 {
+		that.Error = err[0]
+	}
+	return ObjToMapArray(that.Data, &that.Error)
+}
+
+func (that *Obj) ToObj() interface{} {
+
+	return that.Data
+}
+
+//获取向上取整Int64
+func (that *Obj) ToCeilInt64(err ...*Error) int64 {
+	if len(err) != 0 {
+		that.Error = *err[0]
+	}
+	v := ObjToCeilInt64(that.Data, err...)
+	return v
+
+}
+
+//获取向上取整Int
+func (that *Obj) ToCeilInt(err ...*Error) int {
+	if len(err) != 0 {
+		that.Error = *err[0]
+	}
+	v := ObjToCeilInt(that.Data, err...)
+	return v
+
+}

common/objtoobj.go

@@ -1,4 +1,4 @@
-package hotime
+package common
 
 import (
 	"encoding/json"
@@ -135,6 +135,15 @@ func ObjToFloat64(obj interface{}, e ...*Error) float64 {
 			err = errors.New("没有合适的转换对象！")
 		}
 	}
+
+	if math.IsNaN(v) {
+		err = errors.New("float64 is NaN")
+		v = 0
+	}
+	if math.IsInf(v, 0) {
+		err = errors.New("float64 is Inf")
+		v = 0
+	}
 	if len(e) != 0 {
 		e[0].SetError(err)
 	}
@@ -212,6 +221,31 @@ func ObjToInt(obj interface{}, e ...*Error) int {
 	return int(v)
 }
 
+func ObjToBool(obj interface{}, e ...*Error) bool {
+	var err error
+	v := false
+
+	if obj == nil {
+
+		err = errors.New("没有合适的转换对象！")
+	} else {
+		switch obj.(type) {
+		case bool:
+			v = obj.(bool)
+		default:
+			toInt := ObjToInt(obj)
+			if toInt != 0 {
+				v = true
+			}
+			err = errors.New("没有合适的转换对象！")
+		}
+	}
+	if len(e) != 0 {
+		e[0].SetError(err)
+	}
+	return v
+}
+
 func ObjToStr(obj interface{}) string {
 	//	fmt.Println(reflect.ValueOf(obj).Type().String() )
 	str := ""
@@ -232,7 +266,8 @@ func ObjToStr(obj interface{}) string {
 	case float64:
 		str = strconv.FormatFloat(obj.(float64), 'f', -1, 64)
 	default:
-		strbte, err := json.Marshal(obj)
+		strbte, err := json.MarshalIndent(obj, "", "\t")
+
 		if err == nil {
 			str = string(strbte)
 		}

common/slice.go

@@ -0,0 +1,96 @@
+package common
+
+import (
+	"errors"
+)
+
+type Slice []interface{}
+
+// GetString 获取string
+func (that Slice) GetString(key int, err ...*Error) string {
+	if len(err) != 0 {
+		err[0].SetError(nil)
+	}
+	return ObjToStr((that)[key])
+}
+
+// GetInt 获取Int
+func (that Slice) GetInt(key int, err ...*Error) int {
+	v := ObjToInt((that)[key], err...)
+	return v
+}
+
+// GetInt64 获取Int
+func (that Slice) GetInt64(key int, err ...*Error) int64 {
+	v := ObjToInt64((that)[key], err...)
+
+	return v
+}
+
+// GetCeilInt64 获取向上取整Int64
+func (that Slice) GetCeilInt64(key int, err ...*Error) int64 {
+	v := ObjToCeilInt64((that)[key], err...)
+	return v
+
+}
+
+// GetCeilInt 获取向上取整Int
+func (that Slice) GetCeilInt(key int, err ...*Error) int {
+	v := ObjToCeilInt((that)[key], err...)
+	return v
+
+}
+
+// GetCeilFloat64 获取向上取整float64
+func (that Slice) GetCeilFloat64(key int, err ...*Error) float64 {
+	v := ObjToCeilFloat64((that)[key], err...)
+	return v
+
+}
+
+// GetFloat64 获取Float64
+func (that Slice) GetFloat64(key int, err ...*Error) float64 {
+	v := ObjToFloat64((that)[key], err...)
+
+	return v
+}
+
+func (that Slice) GetSlice(key int, err ...*Error) Slice {
+	v := ObjToSlice((that)[key], err...)
+	return v
+}
+
+func (that Slice) GetBool(key int, err ...*Error) bool {
+
+	//var v Slice
+	v := ObjToBool((that)[key], err...)
+
+	return v
+
+}
+
+func (that Slice) GetMap(key int, err ...*Error) Map {
+	//var v Map
+	v := ObjToMap((that)[key], err...)
+	return v
+}
+
+func (that Slice) Get(key int, err ...*Error) interface{} {
+
+	if key < len(that) {
+		return that[key]
+	}
+	e := errors.New("没有存储key及对应的数据")
+	if len(err) != 0 {
+		err[0].SetError(e)
+	}
+	return nil
+}
+
+func (that Slice) Put(key int, value interface{}) {
+	that[key] = value
+}
+
+func (that Slice) ToJsonString() string {
+	return ObjToStr(that)
+}

const.go

@@ -1,16 +1,4 @@
 package hotime
 
-type LOG_MODE int
-
-const (
-	LOG_NIL = 0
-	LOG_FMT = 1
-	//LOG_FILE  = 2
-
-	LOG_INFO  LOG_MODE = 0
-	LOG_WARN  LOG_MODE = 1
-	LOG_ERROR LOG_MODE = 2
-)
-
-//session储存头
+// HEAD_SESSION_ADD session储存头
 const HEAD_SESSION_ADD = "session#"

context.go

@@ -1,65 +1,72 @@
 package hotime
 
 import (
+	. "./cache"
+	. "./common"
+	. "./db"
 	"encoding/json"
-	"errors"
 	"net/http"
 )
 
 type Context struct {
-	contextBase
+	*Application
 	Resp         http.ResponseWriter
 	Req          *http.Request
-	Application  *Application
 	RouterString []string
 	Config       Map
 	Db           *HoTimeDB
 	RespData     Map
 	CacheIns
 	SessionIns
+	DataSize   int
 	HandlerStr string //复写请求url
 }
 
-//唯一标志
-func (this *Context) Mtd(router [3]string) Map {
-	this.Application.Router[router[0]][router[1]][router[2]](this)
-	d := this.RespData
-	this.RespData = nil
+// Mtd 唯一标志
+func (that *Context) Mtd(router [3]string) Map {
+	that.Application.Router[router[0]][router[1]][router[2]](that)
+	d := that.RespData
+	that.RespData = nil
 	return d
 }
 
 //打印
-func (this *Context) Display(statu int, data interface{}) {
+func (that *Context) Display(statu int, data interface{}) {
 
-	resp := Map{"statu": statu}
+	resp := Map{"status": statu}
 	if statu != 0 {
 		temp := Map{}
 
-		tpe := this.Config.GetMap("error").GetString(ObjToStr(statu))
+		tpe := that.Config.GetMap("error").GetString(ObjToStr(statu))
 		if tpe == "" {
-			logFmt(errors.New("找不到对应的错误码"), 2, LOG_WARN)
+			//logFmt(errors.New("找不到对应的错误码"), 2, LOG_WARN)
 		}
 
 		temp["type"] = tpe
 		temp["msg"] = data
 		resp["result"] = temp
+		//兼容android等需要json转对象的服务
+		resp["error"] = temp
 	} else {
 		resp["result"] = data
 	}
 
-	this.RespData = resp
+	that.RespData = resp
 
-	//this.Data=d;
+	//that.Data=d;
 }
 
-func (this *Context) View() {
-	if this.RespData == nil {
+func (that *Context) View() {
+
+	if that.RespData == nil {
 		return
 	}
-	d, err := json.Marshal(this.RespData)
+	d, err := json.Marshal(that.RespData)
 	if err != nil {
 		return
 	}
-	this.RespData = nil
-	this.Resp.Write(d)
+	that.DataSize = len(d)
+	that.RespData = nil
+	that.Resp.Write(d)
+	return
 }

context_base.go

@@ -1,17 +0,0 @@
-package hotime
-
-import "time"
-
-type contextBase struct {
-	Error
-	tag int64
-}
-
-//唯一标志
-func (this *contextBase) GetTag() int64 {
-
-	if this.tag == int64(0) {
-		this.tag = time.Now().UnixNano()
-	}
-	return this.tag
-}

db.go

@@ -1,935 +0,0 @@
-package hotime
-
-import (
-	"database/sql"
-	"encoding/json"
-	"errors"
-	"os"
-	"reflect"
-	"strings"
-)
-
-type HoTimeDB struct {
-	*sql.DB
-	contextBase
-	CacheIns
-	Type        string
-	DBCached    bool
-	LastQuery   string
-	LastData    []interface{}
-	ConnectFunc func(err ...*Error) *sql.DB
-	LastErr     Error
-	limit       Slice
-	Tx          *sql.Tx //事务对象
-
-}
-
-//设置数据库配置连接
-func (this *HoTimeDB) SetConnect(connect func(err ...*Error) *sql.DB, err ...*Error) {
-	this.ConnectFunc = connect
-	this.InitDb()
-}
-
-//事务，如果action返回true则执行成功；false则回滚
-func (this *HoTimeDB) Action(action func(db HoTimeDB) bool) bool {
-	db := HoTimeDB{DB: this.DB, CacheIns: this.CacheIns, DBCached: this.DBCached}
-	tx, err := db.Begin()
-	if err != nil {
-		this.LastErr.SetError(err)
-		return false
-	}
-
-	db.Tx = tx
-
-	result := action(db)
-
-	if !result {
-		db.Tx.Rollback()
-		return result
-	}
-	db.Tx.Commit()
-	return result
-}
-
-func (this *HoTimeDB) InitDb(err ...*Error) Error {
-	if len(err) != 0 {
-		this.LastErr = *(err[0])
-	}
-	this.DB = this.ConnectFunc(&this.LastErr)
-	if this.DB == nil {
-
-		return this.LastErr
-	}
-	e := this.DB.Ping()
-
-	this.LastErr.SetError(e)
-
-	return this.LastErr
-}
-
-func (this *HoTimeDB) Page(page, pageRow int) *HoTimeDB {
-	page = (page - 1) * pageRow
-	if page < 0 {
-		page = 1
-	}
-
-	this.limit = Slice{page, pageRow}
-	return this
-}
-
-func (this *HoTimeDB) PageSelect(table string, qu ...interface{}) []Map {
-
-	if len(qu) == 1 {
-		qu = append(qu, Map{"LIMIT": this.limit})
-	}
-	if len(qu) == 2 {
-		temp := qu[1].(Map)
-		temp["LIMIT"] = this.limit
-		qu[1] = temp
-	}
-	if len(qu) == 3 {
-		temp := qu[2].(Map)
-		temp["LIMIT"] = this.limit
-		qu[2] = temp
-	}
-	//fmt.Println(qu)
-	data := this.Select(table, qu...)
-
-	return data
-}
-
-//数据库数据解析
-func (this *HoTimeDB) Row(resl *sql.Rows) []Map {
-	dest := make([]Map, 0)
-	strs, _ := resl.Columns()
-
-	for i := 0; resl.Next(); i++ {
-		lis := make(Map, 0)
-		a := make([]interface{}, len(strs))
-
-		b := make([]interface{}, len(a))
-		for j := 0; j < len(a); j++ {
-			b[j] = &a[j]
-		}
-		resl.Scan(b...)
-		for j := 0; j < len(a); j++ {
-			if a[j] != nil && reflect.ValueOf(a[j]).Type().String() == "[]uint8" {
-				lis[strs[j]] = string(a[j].([]byte))
-			} else {
-				lis[strs[j]] = a[j]
-			}
-
-		}
-		//防止int被误读为float64
-		jlis, e := json.Marshal(lis)
-		if e != nil {
-			this.LastErr.SetError(e)
-		} else {
-			lis.JsonToMap(string(jlis), &this.LastErr)
-		}
-
-		dest = append(dest, lis)
-
-	}
-
-	return dest
-}
-
-//
-////code=0,1,2 0 backup all,1 backup data,2 backup ddl
-//func (this *HoTimeDB) Backup(path string, code int) {
-//	var cmd *exec.Cmd
-//	switch code {
-//	case 0:cmd= exec.Command("mysqldump","-h"+ObjToStr(Config["dbHost"]), "-P"+ObjToStr(Config["dbPort"]),"-u"+ObjToStr(Config["dbUser"]), "-p"+ObjToStr(Config["dbPwd"]),ObjToStr(Config["dbName"]))
-//	case 1:cmd= exec.Command("mysqldump","-h"+ObjToStr(Config["dbHost"]), "-P"+ObjToStr(Config["dbPort"]),"-u"+ObjToStr(Config["dbUser"]), "-p"+ObjToStr(Config["dbPwd"]), ObjToStr(Config["dbName"]))
-//	case 2:cmd= exec.Command("mysqldump","--no-data","-h"+ObjToStr(Config["dbHost"]), "-P"+ObjToStr(Config["dbPort"]),"-u"+ObjToStr(Config["dbUser"]), "-p"+ObjToStr(Config["dbPwd"]),ObjToStr(Config["dbName"]))
-//	}
-//
-//
-//
-//	stdout, err := cmd.StdoutPipe()
-//	if err != nil {
-//		log.Println(err)
-//	}
-//
-//	if err := cmd.Start(); err != nil {
-//		log.Println(err)
-//	}
-//
-//	bytes, err := ioutil.ReadAll(stdout)
-//	if err != nil {
-//		log.Println(err)
-//	}
-//	err = ioutil.WriteFile(path, bytes, 0644)
-//	if err != nil {
-//		panic(err)
-//	}
-//	return ;
-//	//
-//	//db := ``
-//	//fmt.Println(db)
-//	//
-//	//tables := this.Query("show tables")
-//	//lth := len(tables)
-//	//if lth == 0 {
-//	//	return
-//	//}
-//	//for k, _ := range tables[0] {
-//	//	db = Substr(k, 10, len(k))
-//	//}
-//	//
-//	//fd, _ := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0644)
-//	//fd.Write([]byte("/*datetime " + time.Now().Format("2006-01-02 15:04:05") + "  */ \r\n"))
-//	//fd.Close()
-//	//
-//	//for i := 0; i < lth; i++ {
-//	//	tt := tables[i]["Tables_in_"+db].(string)
-//	//	this.backupSave(path, tt, code)
-//	//	debug.FreeOSMemory()
-//	//}
-//
-//}
-
-func (this *HoTimeDB) backupSave(path string, tt string, code int) {
-	fd, _ := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0644)
-	defer fd.Close()
-
-	str := "\r\n"
-	if code == 0 || code == 2 {
-		str += this.backupDdl(tt)
-	}
-
-	if code == 0 || code == 1 {
-		str += "insert  into `" + tt + "`\r\n\r\n("
-		str += this.backupCol(tt)
-	}
-
-	fd.Write([]byte(str))
-}
-func (this *HoTimeDB) backupDdl(tt string) string {
-
-	data := this.Query("show create table " + tt)
-	if len(data) == 0 {
-		return ""
-	}
-
-	return ObjToStr(data[0]["Create Table"]) + ";\r\n\r\n"
-}
-
-func (this *HoTimeDB) backupCol(tt string) string {
-	str := ""
-	data := this.Select(tt, "*")
-
-	lthData := len(data)
-
-	if lthData == 0 {
-		return str
-	}
-	lthCol := len(data[0])
-	col := make([]string, lthCol)
-	tempLthData := 0
-	for k, _ := range data[0] {
-
-		if tempLthData == lthCol-1 {
-			str += "`" + k + "`)"
-		} else {
-			str += "`" + k + "`,"
-		}
-		col[tempLthData] = k
-		tempLthData++
-	}
-
-	str += " values"
-
-	for j := 0; j < lthData; j++ {
-
-		for m := 0; m < lthCol; m++ {
-
-			if m == 0 {
-				str += "("
-			}
-
-			v := "NULL"
-			if data[j][col[m]] != nil {
-				v = "'" + strings.Replace(ObjToStr(data[j][col[m]]), "'", `\'`, -1) + "'"
-			}
-
-			if m == lthCol-1 {
-				str += v + ")"
-
-			} else {
-				str += v + ","
-			}
-		}
-		if j == lthData-1 {
-			str += ";\r\n\r\n"
-		} else {
-			str += ",\r\n\r\n"
-		}
-	}
-	return str
-}
-
-func (this *HoTimeDB) md5(query string, args ...interface{}) string {
-	strByte, _ := json.Marshal(args)
-	str := Md5(query + ":" + string(strByte))
-	return str
-}
-
-func (this *HoTimeDB) Query(query string, args ...interface{}) []Map {
-
-	//fmt.Println(query)
-	var err error
-	var resl *sql.Rows
-
-	this.LastQuery = query
-	this.LastData = args
-
-	if this.DB == nil {
-		err = errors.New("没有初始化数据库")
-		this.LastErr.SetError(err)
-		return nil
-	}
-
-	if this.Tx != nil {
-		resl, err = this.Tx.Query(query, args...)
-	} else {
-		resl, err = this.DB.Query(query, args...)
-	}
-
-	this.LastErr.SetError(err)
-	if err != nil {
-		if err = this.DB.Ping(); err != nil {
-			this.LastErr.SetError(err)
-			this.InitDb()
-			if this.LastErr.GetError() != nil {
-				return nil
-			}
-			return this.Query(query, args...)
-		}
-		return nil
-	}
-
-	return this.Row(resl)
-}
-
-func (this *HoTimeDB) Exec(query string, args ...interface{}) (sql.Result, Error) {
-
-	this.LastQuery = query
-	this.LastData = args
-	var e error
-	var resl sql.Result
-
-	if this.DB == nil {
-		err := errors.New("没有初始化数据库")
-		this.LastErr.SetError(err)
-		return nil, this.LastErr
-	}
-
-	if this.Tx != nil {
-		resl, e = this.Tx.Exec(query, args...)
-	} else {
-		resl, e = this.DB.Exec(query, args...)
-	}
-
-	this.LastErr.SetError(e)
-
-	//判断是否连接断开了
-	if e != nil {
-
-		if e = this.DB.Ping(); e != nil {
-			this.LastErr.SetError(e)
-			this.InitDb()
-			if this.LastErr.GetError() != nil {
-				return resl, this.LastErr
-			}
-			return this.Exec(query, args...)
-		}
-	}
-
-	return resl, this.LastErr
-}
-
-//func (this *HoTimeDB)copy(data []Map)[]Map{
-//	if data==nil{
-//		return nil
-//	}
-//
-//	lth:=len(data)
-//
-//	res:=make([]Map,lth)
-//
-//
-//	for i:=0;i<lth;i++{
-//
-//		res[i]=DeepCopy(data[i]).(Map)
-//	}
-//
-//	return res
-//
-//}
-func (this *HoTimeDB) Select(table string, qu ...interface{}) []Map {
-
-	query := "SELECT"
-	where := Map{}
-	qs := make([]interface{}, 0)
-	intQs, intWhere := 0, 1
-	join := false
-	if len(qu) == 3 {
-		intQs = 1
-		intWhere = 2
-		join = true
-
-	}
-
-	if len(qu) > 0 {
-		if reflect.ValueOf(qu[intQs]).Type().String() == "string" {
-			query += " " + qu[intQs].(string)
-		} else {
-			for i := 0; i < len(qu[intQs].(Slice)); i++ {
-				k := qu[intQs].(Slice)[i].(string)
-				if strings.Contains(k, " AS ") {
-
-					query += " " + k + " "
-
-				} else {
-					query += " `" + k + "` "
-				}
-
-				if i+1 != len(qu[intQs].(Slice)) {
-					query = query + ", "
-				}
-
-			}
-		}
-
-	} else {
-		query += " *"
-	}
-
-	query += " FROM " + table
-
-	if join {
-		for k, v := range qu[0].(Map) {
-			switch Substr(k, 0, 3) {
-			case "[>]":
-				query += " LEFT JOIN " + Substr(k, 3, len(k)-3) + " ON " + v.(string)
-			case "[<]":
-				query += " RIGHT JOIN " + Substr(k, 3, len(k)-3) + " ON " + v.(string)
-			}
-			switch Substr(k, 0, 4) {
-			case "[<>]":
-				query += " FULL JOIN " + Substr(k, 4, len(k)-4) + " ON " + v.(string)
-			case "[><]":
-				query += " INNER JOIN " + Substr(k, 4, len(k)-4) + " ON " + v.(string)
-			}
-		}
-	}
-
-	if len(qu) > 1 {
-		where = qu[intWhere].(Map)
-	}
-
-	temp, resWhere := this.where(where)
-
-	query += temp
-	qs = append(qs, resWhere...)
-	md5 := this.md5(query, qs...)
-
-	if this.DBCached && this.CacheIns != nil {
-		//如果缓存有则从缓存取
-		cacheData := this.Cache(table + ":" + md5)
-
-		if cacheData.Data != nil {
-			return cacheData.ToMapArray()
-		}
-	}
-
-	//无缓存则数据库取
-	res := this.Query(query, qs...)
-
-	if res == nil {
-		res = []Map{}
-	}
-
-	//缓存
-	if this.DBCached && this.CacheIns != nil {
-
-		this.Cache(table+":"+md5, res)
-	}
-
-	return res
-
-}
-
-func (this *HoTimeDB) Get(table string, qu ...interface{}) Map {
-	//fmt.Println(qu)
-	if len(qu) == 1 {
-		qu = append(qu, Map{"LIMIT": 1})
-	}
-	if len(qu) == 2 {
-		temp := qu[1].(Map)
-		temp["LIMIT"] = 1
-		qu[1] = temp
-	}
-	if len(qu) == 3 {
-		temp := qu[2].(Map)
-		temp["LIMIT"] = 1
-		qu[2] = temp
-	}
-	//fmt.Println(qu)
-	data := this.Select(table, qu...)
-	if len(data) == 0 {
-		return nil
-	}
-	return data[0]
-}
-
-/**
-** 计数
- */
-func (this *HoTimeDB) Count(table string, qu ...interface{}) int {
-	req := []interface{}{}
-
-	if len(qu) == 2 {
-		req = append(req, qu[0])
-		req = append(req, "COUNT(*)")
-		req = append(req, qu[1])
-	} else {
-		req = append(req, "COUNT(*)")
-		req = append(req, qu...)
-	}
-
-	//req=append(req,qu...)
-	data := this.Select(table, req...)
-	//fmt.Println(data)
-	if len(data) == 0 {
-		return 0
-	}
-	//res,_:=StrToInt(data[0]["COUNT(*)"].(string))
-	res := ObjToStr(data[0]["COUNT(*)"])
-	count, _ := StrToInt(res)
-	return count
-
-}
-
-var condition = []string{"AND", "OR"}
-var vcond = []string{"GROUP", "ORDER", "LIMIT"}
-
-//where语句解析
-func (this *HoTimeDB) where(data Map) (string, []interface{}) {
-
-	where := ""
-
-	res := make([]interface{}, 0)
-	//AND OR判断
-	for k, v := range data {
-		x := 0
-		for i := 0; i < len(condition); i++ {
-
-			if condition[i] == k {
-
-				tw, ts := this.cond(k, v.(Map))
-
-				where += tw
-				res = append(res, ts...)
-				break
-			}
-			x++
-		}
-
-		y := 0
-		for j := 0; j < len(vcond); j++ {
-
-			if vcond[j] == k {
-				break
-			}
-			y++
-		}
-		if x == len(condition) && y == len(vcond) {
-			tv, vv := this.varCond(k, v)
-
-			where += tv
-			res = append(res, vv...)
-		}
-
-	}
-
-	if len(where) != 0 {
-		where = " WHERE " + where
-	}
-
-	//特殊字符
-	for j := 0; j < len(vcond); j++ {
-		for k, v := range data {
-			if vcond[j] == k {
-				if k == "ORDER" {
-					where += " " + k + " BY "
-					//fmt.Println(reflect.ValueOf(v).Type())
-
-					//break
-				} else if k == "GROUP" {
-
-					where += " " + k + " BY "
-				} else {
-
-					where += " " + k
-				}
-
-				if reflect.ValueOf(v).Type().String() == "hotime.Slice" {
-					for i := 0; i < len(v.(Slice)); i++ {
-						where += " " + ObjToStr(v.(Slice)[i])
-
-						if len(v.(Slice)) != i+1 {
-							where += ","
-						}
-
-					}
-
-				} else {
-					//fmt.Println(v)
-					where += " " + ObjToStr(v)
-				}
-
-				break
-			}
-		}
-
-	}
-
-	return where, res
-
-}
-
-func (this *HoTimeDB) varCond(k string, v interface{}) (string, []interface{}) {
-	where := ""
-	res := make([]interface{}, 0)
-	length := len(k)
-	if length > 4 {
-		def := false
-
-		switch Substr(k, length-3, 3) {
-		case "[>]":
-			k = strings.Replace(k, "[>]", "", -1)
-			where += "`" + k + "`>? "
-			res = append(res, v)
-		case "[<]":
-			k = strings.Replace(k, "[<]", "", -1)
-			where += "`" + k + "`<? "
-			res = append(res, v)
-		case "[!]":
-			k = strings.Replace(k, "[!]", "", -1)
-			where, res = this.notIn(k, v, where, res)
-		case "[#]":
-			k = strings.Replace(k, "[#]", "", -1)
-			where += " " + k + "=" + ObjToStr(v)
-		case "[#!]":
-			k = strings.Replace(k, "[#!]", "", -1)
-			where += " " + k + "!=" + ObjToStr(v)
-		case "[!#]":
-			k = strings.Replace(k, "[!#]", "", -1)
-			where += " " + k + "!=" + ObjToStr(v)
-		case "[~]":
-			k = strings.Replace(k, "[~]", "", -1)
-			where += "`" + k + "` LIKE ? "
-			v = "%" + ObjToStr(v) + "%"
-			res = append(res, v)
-		case "[!~]": //左边任意
-			k = strings.Replace(k, "[~]", "", -1)
-			where += "`" + k + "` LIKE ? "
-			v = "%" + ObjToStr(v)
-			res = append(res, v)
-		case "[~!]": //右边任意
-			k = strings.Replace(k, "[~]", "", -1)
-			where += "`" + k + "` LIKE ? "
-			v = ObjToStr(v) + "%"
-			res = append(res, v)
-		case "[~~]": //手动任意
-			k = strings.Replace(k, "[~]", "", -1)
-			where += "`" + k + "` LIKE ? "
-			//v = ObjToStr(v)
-			res = append(res, v)
-		default:
-			def = true
-
-		}
-		if def {
-			switch Substr(k, length-4, 4) {
-			case "[>=]":
-				k = strings.Replace(k, "[>=]", "", -1)
-				where += "`" + k + "`>=? "
-				res = append(res, v)
-			case "[<=]":
-				k = strings.Replace(k, "[<=]", "", -1)
-				where += "`" + k + "`<=? "
-				res = append(res, v)
-			case "[><]":
-				k = strings.Replace(k, "[><]", "", -1)
-				where += "`" + k + "` NOT BETWEEN ? AND ? "
-				res = append(res, v.(Slice)[0])
-				res = append(res, v.(Slice)[1])
-			case "[<>]":
-				k = strings.Replace(k, "[<>]", "", -1)
-				where += "`" + k + "` BETWEEN ? AND ? "
-				res = append(res, v.(Slice)[0])
-				res = append(res, v.(Slice)[1])
-			default:
-				if reflect.ValueOf(v).Type().String() == "hotime.Slice" {
-					where += "`" + k + "` IN ("
-					res = append(res, (v.(Slice))...)
-					if len(v.(Slice)) == 0 {
-						where += ") "
-					} else {
-						for i := 0; i < len(v.(Slice)); i++ {
-							if i+1 != len(v.(Slice)) {
-								where += "?,"
-							} else {
-								where += "?) "
-							}
-							//res=append(res,(v.(Slice))[i])
-						}
-					}
-
-				} else {
-					where += "`" + k + "`=? "
-					res = append(res, v)
-				}
-
-			}
-		}
-
-	} else if k == "[#]" {
-		k = strings.Replace(k, "[#]", "", -1)
-		where += " " + ObjToStr(v) + " "
-	} else {
-		//fmt.Println(reflect.ValueOf(v).Type().String())
-		if v == nil {
-			where += "`" + k + "` IS NULL"
-		} else if reflect.ValueOf(v).Type().String() == "hotime.Slice" {
-
-			//fmt.Println(v)
-			where += "`" + k + "` IN ("
-			res = append(res, (v.(Slice))...)
-			for i := 0; i < len(v.(Slice)); i++ {
-				if i+1 != len(v.(Slice)) {
-					where += "?,"
-				} else {
-					where += "?) "
-				}
-				//res=append(res,(v.(Slice))[i])
-			}
-		} else if reflect.ValueOf(v).Type().String() == "[]interface {}" {
-			where += "`" + k + "` IN ("
-			res = append(res, (v.([]interface{}))...)
-			for i := 0; i < len(v.([]interface{})); i++ {
-				if i+1 != len(v.([]interface{})) {
-					where += "?,"
-				} else {
-					where += "?) "
-				}
-				//res=append(res,(v.(Slice))[i])
-			}
-		} else {
-
-			where += "`" + k + "`=? "
-			res = append(res, v)
-
-		}
-	}
-
-	return where, res
-}
-
-//	this.Db.Update("user",hotime.Map{"ustate":"1"},hotime.Map{"AND":hotime.Map{"OR":hotime.Map{"uid":4,"uname":"dasda"}},"ustate":1})
-func (this *HoTimeDB) notIn(k string, v interface{}, where string, res []interface{}) (string, []interface{}) {
-	//where:=""
-	//fmt.Println(reflect.ValueOf(v).Type().String())
-	if v == nil {
-
-		where += "`" + k + "` IS NOT NULL "
-
-	} else if reflect.ValueOf(v).Type().String() == "hotime.Slice" {
-		where += "`" + k + "` NOT IN ("
-		res = append(res, (v.(Slice))...)
-		for i := 0; i < len(v.(Slice)); i++ {
-			if i+1 != len(v.(Slice)) {
-				where += "?,"
-			} else {
-				where += "?) "
-			}
-			//res=append(res,(v.(Slice))[i])
-		}
-	} else if reflect.ValueOf(v).Type().String() == "[]interface {}" {
-		where += "`" + k + "` NOT IN ("
-		res = append(res, (v.([]interface{}))...)
-		for i := 0; i < len(v.([]interface{})); i++ {
-			if i+1 != len(v.([]interface{})) {
-				where += "?,"
-			} else {
-				where += "?) "
-			}
-			//res=append(res,(v.(Slice))[i])
-		}
-	} else {
-
-		where += "`" + k + "` !=? "
-		res = append(res, v)
-
-	}
-
-	return where, res
-}
-
-func (this *HoTimeDB) cond(tag string, data Map) (string, []interface{}) {
-	where := " "
-	res := make([]interface{}, 0)
-	lens := len(data)
-	//fmt.Println(lens)
-	for k, v := range data {
-		x := 0
-		for i := 0; i < len(condition); i++ {
-
-			if condition[i] == k {
-
-				tw, ts := this.cond(k, v.(Map))
-				if lens--; lens <= 0 {
-					//fmt.Println(lens)
-					where += "(" + tw + ") "
-				} else {
-					where += "(" + tw + ") " + tag + " "
-				}
-
-				res = append(res, ts...)
-				break
-			}
-			x++
-		}
-
-		if x == len(condition) {
-
-			tv, vv := this.varCond(k, v)
-
-			res = append(res, vv...)
-			if lens--; lens <= 0 {
-				where += tv + ""
-			} else {
-				where += tv + " " + tag + " "
-			}
-		}
-
-	}
-
-	return where, res
-}
-
-//更新数据
-func (this *HoTimeDB) Update(table string, data Map, where Map) int64 {
-
-	query := "UPDATE " + table + " SET "
-	//UPDATE Person SET Address = 'Zhongshan 23', City = 'Nanjing' WHERE LastName = 'Wilson'
-	qs := make([]interface{}, 0)
-	tp := len(data)
-
-	for k, v := range data {
-		vstr := "?"
-		if Substr(k, len(k)-3, 3) == "[#]" {
-			k = strings.Replace(k, "[#]", "", -1)
-
-			vstr = ObjToStr(v)
-		} else {
-			qs = append(qs, v)
-		}
-		query += "`" + k + "`=" + vstr + ""
-		if tp--; tp != 0 {
-			query += ", "
-		}
-	}
-
-	temp, resWhere := this.where(where)
-	//fmt.Println(resWhere)
-
-	query += temp
-	qs = append(qs, resWhere...)
-
-	res, err := this.Exec(query, qs...)
-
-	rows := int64(0)
-	if err.GetError() == nil && res != nil {
-		rows, _ = res.RowsAffected()
-	}
-
-	//如果更新成功，则删除缓存
-	if rows != 0 {
-		if this.DBCached && this.CacheIns != nil {
-			this.Cache(table+"*", nil)
-		}
-	}
-
-	return rows
-}
-
-func (this *HoTimeDB) Delete(table string, data map[string]interface{}) int64 {
-
-	query := "DELETE FROM " + table + " "
-
-	temp, resWhere := this.where(data)
-	query += temp
-
-	res, err := this.Exec(query, resWhere...)
-	rows := int64(0)
-	if err.GetError() == nil && res != nil {
-		rows, _ = res.RowsAffected()
-	}
-
-	//如果删除成功,删除对应缓存
-	if rows != 0 {
-		if this.DBCached && this.CacheIns != nil {
-			this.Cache(table+"*", nil)
-		}
-	}
-	//return 0
-
-	return rows
-}
-
-//插入新数据
-func (this *HoTimeDB) Insert(table string, data map[string]interface{}) int64 {
-
-	values := make([]interface{}, 0)
-	queryString := " ("
-	valueString := " ("
-
-	lens := len(data)
-	tempLen := 0
-	for k, v := range data {
-		tempLen++
-		values = append(values, v)
-		if tempLen < lens {
-			queryString += "`" + k + "`,"
-			valueString += "?,"
-		} else {
-			queryString += "`" + k + "`) "
-			valueString += "?);"
-		}
-
-	}
-	query := "INSERT INTO " + table + queryString + "VALUES" + valueString
-
-	res, err := this.Exec(query, values...)
-
-	id := int64(0)
-	if err.GetError() == nil && res != nil {
-		id, this.LastErr.err = res.LastInsertId()
-
-	}
-
-	//如果插入成功，删除缓存
-	if id != 0 {
-		if this.DBCached && this.CacheIns != nil {
-			this.Cache(table+"*", nil)
-		}
-	}
-
-	//fmt.Println(id)
-	return id
-}

db/hotimedb.go

@@ -1,9 +1,13 @@
-package hotime
+package db
 
 import (
+	"../cache"
+	. "../common"
 	"database/sql"
 	"encoding/json"
 	"errors"
+	_ "github.com/go-sql-driver/mysql"
+	_ "github.com/mattn/go-sqlite3"
 	"os"
 	"reflect"
 	"strings"
@@ -11,31 +15,38 @@ import (
 
 type HoTimeDB struct {
 	*sql.DB
-	contextBase
-	CacheIns
+	ContextBase
+	DBName string
+	*cache.HoTimeCache
 	Type        string
-	DBCached    bool
+	Prefix      string
 	LastQuery   string
 	LastData    []interface{}
-	ConnectFunc func(err ...*Error) *sql.DB
-	LastErr     Error
+	ConnectFunc func(err ...*Error) (*sql.DB, *sql.DB)
+	LastErr     *Error
 	limit       Slice
-	Tx          *sql.Tx //事务对象
+	*sql.Tx     //事务对象
+	SlaveDB     *sql.DB
+}
+
+// SetConnect 设置数据库配置连接
+func (that *HoTimeDB) SetConnect(connect func(err ...*Error) (master, slave *sql.DB), err ...*Error) {
+	that.ConnectFunc = connect
+	_ = that.InitDb(err...)
 
 }
 
-//设置数据库配置连接
-func (this *HoTimeDB) SetConnect(connect func(err ...*Error) *sql.DB, err ...*Error) {
-	this.ConnectFunc = connect
-	this.InitDb()
+// GetType 设置数据库配置连接
+func (that *HoTimeDB) GetType() string {
+	return that.Type
 }
 
-//事务，如果action返回true则执行成功；false则回滚
-func (this *HoTimeDB) Action(action func(db HoTimeDB) bool) bool {
-	db := HoTimeDB{DB: this.DB, CacheIns: this.CacheIns, DBCached: this.DBCached}
+// Action 事务，如果action返回true则执行成功；false则回滚
+func (that *HoTimeDB) Action(action func(db HoTimeDB) bool) bool {
+	db := HoTimeDB{DB: that.DB, HoTimeCache: that.HoTimeCache, Prefix: that.Prefix}
 	tx, err := db.Begin()
 	if err != nil {
-		this.LastErr.SetError(err)
+		that.LastErr.SetError(err)
 		return false
 	}
 
@@ -44,62 +55,74 @@ func (this *HoTimeDB) Action(action func(db HoTimeDB) bool) bool {
 	result := action(db)
 
 	if !result {
-		db.Tx.Rollback()
+		err = db.Tx.Rollback()
+		if err != nil {
+			that.LastErr.SetError(err)
+			return false
+		}
 		return result
 	}
-	db.Tx.Commit()
+	err = db.Tx.Commit()
+	if err != nil {
+		that.LastErr.SetError(err)
+		return false
+	}
 	return result
 }
 
-func (this *HoTimeDB) InitDb(err ...*Error) Error {
+func (that *HoTimeDB) InitDb(err ...*Error) *Error {
 	if len(err) != 0 {
-		this.LastErr = *(err[0])
+		that.LastErr = err[0]
 	}
-	this.DB = this.ConnectFunc(&this.LastErr)
-	if this.DB == nil {
-
-		return this.LastErr
+	that.DB, that.SlaveDB = that.ConnectFunc(that.LastErr)
+	if that.DB == nil {
+		return that.LastErr
 	}
-	e := this.DB.Ping()
+	e := that.DB.Ping()
 
-	this.LastErr.SetError(e)
+	that.LastErr.SetError(e)
 
-	return this.LastErr
+	if that.SlaveDB != nil {
+		e := that.SlaveDB.Ping()
+		that.LastErr.SetError(e)
+	}
+
+	return that.LastErr
 }
 
-func (this *HoTimeDB) Page(page, pageRow int) *HoTimeDB {
+func (that *HoTimeDB) Page(page, pageRow int) *HoTimeDB {
 	page = (page - 1) * pageRow
 	if page < 0 {
 		page = 1
 	}
 
-	this.limit = Slice{page, pageRow}
-	return this
+	that.limit = Slice{page, pageRow}
+	return that
 }
 
-func (this *HoTimeDB) PageSelect(table string, qu ...interface{}) []Map {
+func (that *HoTimeDB) PageSelect(table string, qu ...interface{}) []Map {
 
 	if len(qu) == 1 {
-		qu = append(qu, Map{"LIMIT": this.limit})
+		qu = append(qu, Map{"LIMIT": that.limit})
 	}
 	if len(qu) == 2 {
-		temp := qu[1].(Map)
-		temp["LIMIT"] = this.limit
+		temp := DeepCopyMap(qu[1]).(Map)
+		temp["LIMIT"] = that.limit
 		qu[1] = temp
 	}
 	if len(qu) == 3 {
-		temp := qu[2].(Map)
-		temp["LIMIT"] = this.limit
+		temp := DeepCopyMap(qu[2]).(Map)
+		temp["LIMIT"] = that.limit
 		qu[2] = temp
 	}
 	//fmt.Println(qu)
-	data := this.Select(table, qu...)
+	data := that.Select(table, qu...)
 
 	return data
 }
 
-//数据库数据解析
-func (this *HoTimeDB) Row(resl *sql.Rows) []Map {
+// Row 数据库数据解析
+func (that *HoTimeDB) Row(resl *sql.Rows) []Map {
 	dest := make([]Map, 0)
 	strs, _ := resl.Columns()
 
@@ -111,22 +134,27 @@ func (this *HoTimeDB) Row(resl *sql.Rows) []Map {
 		for j := 0; j < len(a); j++ {
 			b[j] = &a[j]
 		}
-		resl.Scan(b...)
+		err := resl.Scan(b...)
+		if err != nil {
+			that.LastErr.SetError(err)
+			return nil
+		}
 		for j := 0; j < len(a); j++ {
+			//fmt.Println(reflect.ValueOf(a[j]).Type().String() )
 			if a[j] != nil && reflect.ValueOf(a[j]).Type().String() == "[]uint8" {
 				lis[strs[j]] = string(a[j].([]byte))
 			} else {
-				lis[strs[j]] = a[j]
+				lis[strs[j]] = a[j] //取实际类型
 			}
 
 		}
 		//防止int被误读为float64
-		jlis, e := json.Marshal(lis)
-		if e != nil {
-			this.LastErr.SetError(e)
-		} else {
-			lis.JsonToMap(string(jlis), &this.LastErr)
-		}
+		//jlis, e := json.Marshal(lis)
+		//if e != nil {
+		//	that.LastErr.SetError(e)
+		//} else {
+		//	lis.JsonToMap(string(jlis), that.LastErr)
+		//}
 
 		dest = append(dest, lis)
 
@@ -190,25 +218,25 @@ func (this *HoTimeDB) Row(resl *sql.Rows) []Map {
 //
 //}
 
-func (this *HoTimeDB) backupSave(path string, tt string, code int) {
+func (that *HoTimeDB) backupSave(path string, tt string, code int) {
 	fd, _ := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0644)
 	defer fd.Close()
 
 	str := "\r\n"
 	if code == 0 || code == 2 {
-		str += this.backupDdl(tt)
+		str += that.backupDdl(tt)
 	}
 
 	if code == 0 || code == 1 {
 		str += "insert  into `" + tt + "`\r\n\r\n("
-		str += this.backupCol(tt)
+		str += that.backupCol(tt)
 	}
 
-	fd.Write([]byte(str))
+	_, _ = fd.Write([]byte(str))
 }
-func (this *HoTimeDB) backupDdl(tt string) string {
+func (that *HoTimeDB) backupDdl(tt string) string {
 
-	data := this.Query("show create table " + tt)
+	data := that.Query("show create table " + tt)
 	if len(data) == 0 {
 		return ""
 	}
@@ -216,9 +244,9 @@ func (this *HoTimeDB) backupDdl(tt string) string {
 	return ObjToStr(data[0]["Create Table"]) + ";\r\n\r\n"
 }
 
-func (this *HoTimeDB) backupCol(tt string) string {
+func (that *HoTimeDB) backupCol(tt string) string {
 	str := ""
-	data := this.Select(tt, "*")
+	data := that.Select(tt, "*")
 
 	lthData := len(data)
 
@@ -228,7 +256,7 @@ func (this *HoTimeDB) backupCol(tt string) string {
 	lthCol := len(data[0])
 	col := make([]string, lthCol)
 	tempLthData := 0
-	for k, _ := range data[0] {
+	for k := range data[0] {
 
 		if tempLthData == lthCol-1 {
 			str += "`" + k + "`)"
@@ -270,84 +298,89 @@ func (this *HoTimeDB) backupCol(tt string) string {
 	return str
 }
 
-func (this *HoTimeDB) md5(query string, args ...interface{}) string {
+func (that *HoTimeDB) md5(query string, args ...interface{}) string {
 	strByte, _ := json.Marshal(args)
 	str := Md5(query + ":" + string(strByte))
 	return str
 }
 
-func (this *HoTimeDB) Query(query string, args ...interface{}) []Map {
+func (that *HoTimeDB) Query(query string, args ...interface{}) []Map {
 
 	//fmt.Println(query)
 	var err error
 	var resl *sql.Rows
 
-	this.LastQuery = query
-	this.LastData = args
+	that.LastQuery = query
+	that.LastData = args
+	//主从数据库切换，只有select语句有从数据库
+	db := that.DB
+	if that.SlaveDB != nil {
+		db = that.SlaveDB
+	}
 
-	if this.DB == nil {
+	if db == nil {
 		err = errors.New("没有初始化数据库")
-		this.LastErr.SetError(err)
+		that.LastErr.SetError(err)
 		return nil
 	}
 
-	if this.Tx != nil {
-		resl, err = this.Tx.Query(query, args...)
+	if that.Tx != nil {
+		resl, err = that.Tx.Query(query, args...)
 	} else {
-		resl, err = this.DB.Query(query, args...)
+		resl, err = db.Query(query, args...)
 	}
 
-	this.LastErr.SetError(err)
+	that.LastErr.SetError(err)
 	if err != nil {
-		if err = this.DB.Ping(); err != nil {
-			this.LastErr.SetError(err)
-			this.InitDb()
-			if this.LastErr.GetError() != nil {
+		if err = db.Ping(); err != nil {
+			that.LastErr.SetError(err)
+			_ = that.InitDb()
+			if that.LastErr.GetError() != nil {
 				return nil
 			}
-			return this.Query(query, args...)
+			return that.Query(query, args...)
 		}
 		return nil
 	}
 
-	return this.Row(resl)
+	return that.Row(resl)
 }
 
-func (this *HoTimeDB) Exec(query string, args ...interface{}) (sql.Result, Error) {
+func (that *HoTimeDB) Exec(query string, args ...interface{}) (sql.Result, *Error) {
 
-	this.LastQuery = query
-	this.LastData = args
+	that.LastQuery = query
+	that.LastData = args
 	var e error
 	var resl sql.Result
 
-	if this.DB == nil {
+	if that.DB == nil {
 		err := errors.New("没有初始化数据库")
-		this.LastErr.SetError(err)
-		return nil, this.LastErr
+		that.LastErr.SetError(err)
+		return nil, that.LastErr
 	}
 
-	if this.Tx != nil {
-		resl, e = this.Tx.Exec(query, args...)
+	if that.Tx != nil {
+		resl, e = that.Tx.Exec(query, args...)
 	} else {
-		resl, e = this.DB.Exec(query, args...)
+		resl, e = that.DB.Exec(query, args...)
 	}
 
-	this.LastErr.SetError(e)
+	that.LastErr.SetError(e)
 
 	//判断是否连接断开了
 	if e != nil {
 
-		if e = this.DB.Ping(); e != nil {
-			this.LastErr.SetError(e)
-			this.InitDb()
-			if this.LastErr.GetError() != nil {
-				return resl, this.LastErr
+		if e = that.DB.Ping(); e != nil {
+			that.LastErr.SetError(e)
+			_ = that.InitDb()
+			if that.LastErr.GetError() != nil {
+				return resl, that.LastErr
 			}
-			return this.Exec(query, args...)
+			return that.Exec(query, args...)
 		}
 	}
 
-	return resl, this.LastErr
+	return resl, that.LastErr
 }
 
 //func (this *HoTimeDB)copy(data []Map)[]Map{
@@ -368,7 +401,8 @@ func (this *HoTimeDB) Exec(query string, args ...interface{}) (sql.Result, Error
 //	return res
 //
 //}
-func (this *HoTimeDB) Select(table string, qu ...interface{}) []Map {
+
+func (that *HoTimeDB) Select(table string, qu ...interface{}) []Map {
 
 	query := "SELECT"
 	where := Map{}
@@ -406,8 +440,11 @@ func (this *HoTimeDB) Select(table string, qu ...interface{}) []Map {
 	} else {
 		query += " *"
 	}
-
-	query += " FROM " + table
+	if !strings.Contains(table, ".") && !strings.Contains(table, " AS ") {
+		query += " FROM `" + that.Prefix + table + "`"
+	} else {
+		query += " FROM " + that.Prefix + table
+	}
 
 	if join {
 		for k, v := range qu[0].(Map) {
@@ -430,39 +467,39 @@ func (this *HoTimeDB) Select(table string, qu ...interface{}) []Map {
 		where = qu[intWhere].(Map)
 	}
 
-	temp, resWhere := this.where(where)
+	temp, resWhere := that.where(where)
 
 	query += temp
 	qs = append(qs, resWhere...)
-	md5 := this.md5(query, qs...)
+	md5 := that.md5(query, qs...)
 
-	if this.DBCached && this.CacheIns != nil {
+	if that.HoTimeCache != nil && table != "cached" {
 		//如果缓存有则从缓存取
-		cacheData := this.Cache(table + ":" + md5)
+		cacheData := that.HoTimeCache.Db(table + ":" + md5)
 
-		if cacheData.Data != nil {
+		if cacheData != nil && cacheData.Data != nil {
 			return cacheData.ToMapArray()
 		}
 	}
 
 	//无缓存则数据库取
-	res := this.Query(query, qs...)
+	res := that.Query(query, qs...)
 
 	if res == nil {
 		res = []Map{}
 	}
 
 	//缓存
-	if this.DBCached && this.CacheIns != nil {
+	if that.HoTimeCache != nil && table != "cached" {
 
-		this.Cache(table+":"+md5, res)
+		_ = that.HoTimeCache.Db(table+":"+md5, res)
 	}
 
 	return res
 
 }
 
-func (this *HoTimeDB) Get(table string, qu ...interface{}) Map {
+func (that *HoTimeDB) Get(table string, qu ...interface{}) Map {
 	//fmt.Println(qu)
 	if len(qu) == 1 {
 		qu = append(qu, Map{"LIMIT": 1})
@@ -478,19 +515,19 @@ func (this *HoTimeDB) Get(table string, qu ...interface{}) Map {
 		qu[2] = temp
 	}
 	//fmt.Println(qu)
-	data := this.Select(table, qu...)
+	data := that.Select(table, qu...)
 	if len(data) == 0 {
 		return nil
 	}
 	return data[0]
 }
+func (that *HoTimeDB) GetPrefix() string {
+	return that.Prefix
+}
 
-/**
-** 计数
- */
-func (this *HoTimeDB) Count(table string, qu ...interface{}) int {
-	req := []interface{}{}
-
+// Count 计数
+func (that *HoTimeDB) Count(table string, qu ...interface{}) int {
+	var req = []interface{}{}
 	if len(qu) == 2 {
 		req = append(req, qu[0])
 		req = append(req, "COUNT(*)")
@@ -501,7 +538,7 @@ func (this *HoTimeDB) Count(table string, qu ...interface{}) int {
 	}
 
 	//req=append(req,qu...)
-	data := this.Select(table, req...)
+	data := that.Select(table, req...)
 	//fmt.Println(data)
 	if len(data) == 0 {
 		return 0
@@ -517,7 +554,7 @@ var condition = []string{"AND", "OR"}
 var vcond = []string{"GROUP", "ORDER", "LIMIT"}
 
 //where语句解析
-func (this *HoTimeDB) where(data Map) (string, []interface{}) {
+func (that *HoTimeDB) where(data Map) (string, []interface{}) {
 
 	where := ""
 
@@ -529,7 +566,7 @@ func (this *HoTimeDB) where(data Map) (string, []interface{}) {
 
 			if condition[i] == k {
 
-				tw, ts := this.cond(k, v.(Map))
+				tw, ts := that.cond(k, v.(Map))
 
 				where += tw
 				res = append(res, ts...)
@@ -547,7 +584,16 @@ func (this *HoTimeDB) where(data Map) (string, []interface{}) {
 			y++
 		}
 		if x == len(condition) && y == len(vcond) {
-			tv, vv := this.varCond(k, v)
+
+			if v != nil && reflect.ValueOf(v).Type().String() == "common.Slice" && len(v.(Slice)) == 0 {
+				continue
+			}
+
+			if v != nil && reflect.ValueOf(v).Type().String() == "[]interface {}" && len(v.([]interface{})) == 0 {
+				continue
+			}
+
+			tv, vv := that.varCond(k, v)
 
 			where += tv
 			res = append(res, vv...)
@@ -576,7 +622,7 @@ func (this *HoTimeDB) where(data Map) (string, []interface{}) {
 					where += " " + k
 				}
 
-				if reflect.ValueOf(v).Type().String() == "hotime.Slice" {
+				if reflect.ValueOf(v).Type().String() == "common.Slice" {
 					for i := 0; i < len(v.(Slice)); i++ {
 						where += " " + ObjToStr(v.(Slice)[i])
 
@@ -601,52 +647,86 @@ func (this *HoTimeDB) where(data Map) (string, []interface{}) {
 
 }
 
-func (this *HoTimeDB) varCond(k string, v interface{}) (string, []interface{}) {
+func (that *HoTimeDB) varCond(k string, v interface{}) (string, []interface{}) {
+
 	where := ""
 	res := make([]interface{}, 0)
 	length := len(k)
-	if length > 4 {
+	if k == "[#]" {
+		k = strings.Replace(k, "[#]", "", -1)
+		where += " " + ObjToStr(v) + " "
+	} else if length > 0 && strings.Contains(k, "[") && k[length-1] == ']' {
 		def := false
 
 		switch Substr(k, length-3, 3) {
 		case "[>]":
 			k = strings.Replace(k, "[>]", "", -1)
-			where += "`" + k + "`>? "
+			if !strings.Contains(k, ".") {
+				k = "`" + k + "`"
+			}
+			where += k + ">? "
 			res = append(res, v)
 		case "[<]":
 			k = strings.Replace(k, "[<]", "", -1)
-			where += "`" + k + "`<? "
+			if !strings.Contains(k, ".") {
+				k = "`" + k + "`"
+			}
+			where += k + "<? "
 			res = append(res, v)
 		case "[!]":
 			k = strings.Replace(k, "[!]", "", -1)
-			where, res = this.notIn(k, v, where, res)
+			if !strings.Contains(k, ".") {
+				k = "`" + k + "`"
+			}
+			where, res = that.notIn(k, v, where, res)
 		case "[#]":
 			k = strings.Replace(k, "[#]", "", -1)
+			if !strings.Contains(k, ".") {
+				k = "`" + k + "`"
+			}
 			where += " " + k + "=" + ObjToStr(v)
 		case "[#!]":
 			k = strings.Replace(k, "[#!]", "", -1)
+			if !strings.Contains(k, ".") {
+				k = "`" + k + "`"
+			}
 			where += " " + k + "!=" + ObjToStr(v)
 		case "[!#]":
 			k = strings.Replace(k, "[!#]", "", -1)
+			if !strings.Contains(k, ".") {
+				k = "`" + k + "`"
+			}
 			where += " " + k + "!=" + ObjToStr(v)
 		case "[~]":
 			k = strings.Replace(k, "[~]", "", -1)
-			where += "`" + k + "` LIKE ? "
+			if !strings.Contains(k, ".") {
+				k = "`" + k + "`"
+			}
+			where += k + " LIKE ? "
 			v = "%" + ObjToStr(v) + "%"
 			res = append(res, v)
 		case "[!~]": //左边任意
 			k = strings.Replace(k, "[~]", "", -1)
-			where += "`" + k + "` LIKE ? "
+			if !strings.Contains(k, ".") {
+				k = "`" + k + "`"
+			}
+			where += k + " LIKE ? "
 			v = "%" + ObjToStr(v)
 			res = append(res, v)
 		case "[~!]": //右边任意
 			k = strings.Replace(k, "[~]", "", -1)
-			where += "`" + k + "` LIKE ? "
+			if !strings.Contains(k, ".") {
+				k = "`" + k + "`"
+			}
+			where += k + " LIKE ? "
 			v = ObjToStr(v) + "%"
 			res = append(res, v)
 		case "[~~]": //手动任意
 			k = strings.Replace(k, "[~]", "", -1)
-			where += "`" + k + "` LIKE ? "
+			if !strings.Contains(k, ".") {
+				k = "`" + k + "`"
+			}
+			where += k + " LIKE ? "
 			//v = ObjToStr(v)
 			res = append(res, v)
 		default:
@@ -657,26 +737,41 @@ func (this *HoTimeDB) varCond(k string, v interface{}) (string, []interface{}) {
 			switch Substr(k, length-4, 4) {
 			case "[>=]":
 				k = strings.Replace(k, "[>=]", "", -1)
-				where += "`" + k + "`>=? "
+				if !strings.Contains(k, ".") {
+					k = "`" + k + "`"
+				}
+				where += k + ">=? "
 				res = append(res, v)
 			case "[<=]":
 				k = strings.Replace(k, "[<=]", "", -1)
-				where += "`" + k + "`<=? "
+				if !strings.Contains(k, ".") {
+					k = "`" + k + "`"
+				}
+				where += k + "<=? "
 				res = append(res, v)
 			case "[><]":
 				k = strings.Replace(k, "[><]", "", -1)
-				where += "`" + k + "` NOT BETWEEN ? AND ? "
+				if !strings.Contains(k, ".") {
+					k = "`" + k + "`"
+				}
+				where += k + " NOT BETWEEN ? AND ? "
 				res = append(res, v.(Slice)[0])
 				res = append(res, v.(Slice)[1])
 			case "[<>]":
 				k = strings.Replace(k, "[<>]", "", -1)
-				where += "`" + k + "` BETWEEN ? AND ? "
+				if !strings.Contains(k, ".") {
+					k = "`" + k + "`"
+				}
+				where += k + " BETWEEN ? AND ? "
 				res = append(res, v.(Slice)[0])
 				res = append(res, v.(Slice)[1])
 			default:
-				if reflect.ValueOf(v).Type().String() == "hotime.Slice" {
-					where += "`" + k + "` IN ("
-					res = append(res, (v.(Slice))...)
+				if !strings.Contains(k, ".") {
+					k = "`" + k + "`"
+				}
+				if reflect.ValueOf(v).Type().String() == "common.Slice" {
+					where += k + " IN ("
+					res = append(res, v.(Slice)...)
 					if len(v.(Slice)) == 0 {
 						where += ") "
 					} else {
@@ -691,25 +786,25 @@ func (this *HoTimeDB) varCond(k string, v interface{}) (string, []interface{}) {
 					}
 
 				} else {
-					where += "`" + k + "`=? "
+					where += k + "=? "
 					res = append(res, v)
 				}
 
 			}
 		}
 
-	} else if k == "[#]" {
-		k = strings.Replace(k, "[#]", "", -1)
-		where += " " + ObjToStr(v) + " "
 	} else {
 		//fmt.Println(reflect.ValueOf(v).Type().String())
+		if !strings.Contains(k, ".") {
+			k = "`" + k + "`"
+		}
 		if v == nil {
-			where += "`" + k + "` IS NULL"
-		} else if reflect.ValueOf(v).Type().String() == "hotime.Slice" {
+			where += k + " IS NULL"
+		} else if reflect.ValueOf(v).Type().String() == "common.Slice" {
 
 			//fmt.Println(v)
-			where += "`" + k + "` IN ("
-			res = append(res, (v.(Slice))...)
+			where += k + " IN ("
+			res = append(res, v.(Slice)...)
 			for i := 0; i < len(v.(Slice)); i++ {
 				if i+1 != len(v.(Slice)) {
 					where += "?,"
@@ -719,8 +814,9 @@ func (this *HoTimeDB) varCond(k string, v interface{}) (string, []interface{}) {
 				//res=append(res,(v.(Slice))[i])
 			}
 		} else if reflect.ValueOf(v).Type().String() == "[]interface {}" {
-			where += "`" + k + "` IN ("
-			res = append(res, (v.([]interface{}))...)
+
+			where += k + " IN ("
+			res = append(res, v.([]interface{})...)
 			for i := 0; i < len(v.([]interface{})); i++ {
 				if i+1 != len(v.([]interface{})) {
 					where += "?,"
@@ -731,7 +827,7 @@ func (this *HoTimeDB) varCond(k string, v interface{}) (string, []interface{}) {
 			}
 		} else {
 
-			where += "`" + k + "`=? "
+			where += k + "=? "
 			res = append(res, v)
 
 		}
@@ -741,16 +837,16 @@ func (this *HoTimeDB) varCond(k string, v interface{}) (string, []interface{}) {
 }
 
 //	this.Db.Update("user",hotime.Map{"ustate":"1"},hotime.Map{"AND":hotime.Map{"OR":hotime.Map{"uid":4,"uname":"dasda"}},"ustate":1})
-func (this *HoTimeDB) notIn(k string, v interface{}, where string, res []interface{}) (string, []interface{}) {
+func (that *HoTimeDB) notIn(k string, v interface{}, where string, res []interface{}) (string, []interface{}) {
 	//where:=""
 	//fmt.Println(reflect.ValueOf(v).Type().String())
 	if v == nil {
 
-		where += "`" + k + "` IS NOT NULL "
+		where += k + " IS NOT NULL "
 
-	} else if reflect.ValueOf(v).Type().String() == "hotime.Slice" {
-		where += "`" + k + "` NOT IN ("
-		res = append(res, (v.(Slice))...)
+	} else if reflect.ValueOf(v).Type().String() == "common.Slice" {
+		where += k + " NOT IN ("
+		res = append(res, v.(Slice)...)
 		for i := 0; i < len(v.(Slice)); i++ {
 			if i+1 != len(v.(Slice)) {
 				where += "?,"
@@ -760,8 +856,8 @@ func (this *HoTimeDB) notIn(k string, v interface{}, where string, res []interfa
 			//res=append(res,(v.(Slice))[i])
 		}
 	} else if reflect.ValueOf(v).Type().String() == "[]interface {}" {
-		where += "`" + k + "` NOT IN ("
-		res = append(res, (v.([]interface{}))...)
+		where += k + " NOT IN ("
+		res = append(res, v.([]interface{})...)
 		for i := 0; i < len(v.([]interface{})); i++ {
 			if i+1 != len(v.([]interface{})) {
 				where += "?,"
@@ -772,7 +868,7 @@ func (this *HoTimeDB) notIn(k string, v interface{}, where string, res []interfa
 		}
 	} else {
 
-		where += "`" + k + "` !=? "
+		where += k + " !=? "
 		res = append(res, v)
 
 	}
@@ -780,7 +876,7 @@ func (this *HoTimeDB) notIn(k string, v interface{}, where string, res []interfa
 	return where, res
 }
 
-func (this *HoTimeDB) cond(tag string, data Map) (string, []interface{}) {
+func (that *HoTimeDB) cond(tag string, data Map) (string, []interface{}) {
 	where := " "
 	res := make([]interface{}, 0)
 	lens := len(data)
@@ -791,7 +887,7 @@ func (this *HoTimeDB) cond(tag string, data Map) (string, []interface{}) {
 
 			if condition[i] == k {
 
-				tw, ts := this.cond(k, v.(Map))
+				tw, ts := that.cond(k, v.(Map))
 				if lens--; lens <= 0 {
 					//fmt.Println(lens)
 					where += "(" + tw + ") "
@@ -807,7 +903,7 @@ func (this *HoTimeDB) cond(tag string, data Map) (string, []interface{}) {
 
 		if x == len(condition) {
 
-			tv, vv := this.varCond(k, v)
+			tv, vv := that.varCond(k, v)
 
 			res = append(res, vv...)
 			if lens--; lens <= 0 {
@@ -822,10 +918,10 @@ func (this *HoTimeDB) cond(tag string, data Map) (string, []interface{}) {
 	return where, res
 }
 
-//更新数据
-func (this *HoTimeDB) Update(table string, data Map, where Map) int64 {
+// Update 更新数据
+func (that *HoTimeDB) Update(table string, data Map, where Map) int64 {
 
-	query := "UPDATE " + table + " SET "
+	query := "UPDATE `" + that.Prefix + table + "` SET "
 	//UPDATE Person SET Address = 'Zhongshan 23', City = 'Nanjing' WHERE LastName = 'Wilson'
 	qs := make([]interface{}, 0)
 	tp := len(data)
@@ -845,13 +941,13 @@ func (this *HoTimeDB) Update(table string, data Map, where Map) int64 {
 		}
 	}
 
-	temp, resWhere := this.where(where)
+	temp, resWhere := that.where(where)
 	//fmt.Println(resWhere)
 
 	query += temp
 	qs = append(qs, resWhere...)
 
-	res, err := this.Exec(query, qs...)
+	res, err := that.Exec(query, qs...)
 
 	rows := int64(0)
 	if err.GetError() == nil && res != nil {
@@ -860,22 +956,22 @@ func (this *HoTimeDB) Update(table string, data Map, where Map) int64 {
 
 	//如果更新成功，则删除缓存
 	if rows != 0 {
-		if this.DBCached && this.CacheIns != nil {
-			this.Cache(table+"*", nil)
+		if that.HoTimeCache != nil && table != "cached" {
+			_ = that.HoTimeCache.Db(table+"*", nil)
 		}
 	}
 
 	return rows
 }
 
-func (this *HoTimeDB) Delete(table string, data map[string]interface{}) int64 {
+func (that *HoTimeDB) Delete(table string, data map[string]interface{}) int64 {
 
-	query := "DELETE FROM " + table + " "
+	query := "DELETE FROM " + that.Prefix + table + " "
 
-	temp, resWhere := this.where(data)
+	temp, resWhere := that.where(data)
 	query += temp
 
-	res, err := this.Exec(query, resWhere...)
+	res, err := that.Exec(query, resWhere...)
 	rows := int64(0)
 	if err.GetError() == nil && res != nil {
 		rows, _ = res.RowsAffected()
@@ -883,8 +979,8 @@ func (this *HoTimeDB) Delete(table string, data map[string]interface{}) int64 {
 
 	//如果删除成功,删除对应缓存
 	if rows != 0 {
-		if this.DBCached && this.CacheIns != nil {
-			this.Cache(table+"*", nil)
+		if that.HoTimeCache != nil && table != "cached" {
+			_ = that.HoTimeCache.Db(table+"*", nil)
 		}
 	}
 	//return 0
@@ -892,8 +988,8 @@ func (this *HoTimeDB) Delete(table string, data map[string]interface{}) int64 {
 	return rows
 }
 
-//插入新数据
-func (this *HoTimeDB) Insert(table string, data map[string]interface{}) int64 {
+// Insert 插入新数据
+func (that *HoTimeDB) Insert(table string, data map[string]interface{}) int64 {
 
 	values := make([]interface{}, 0)
 	queryString := " ("
@@ -913,20 +1009,21 @@ func (this *HoTimeDB) Insert(table string, data map[string]interface{}) int64 {
 		}
 
 	}
-	query := "INSERT INTO " + table + queryString + "VALUES" + valueString
+	query := "INSERT INTO `" + that.Prefix + table + "` " + queryString + "VALUES" + valueString
 
-	res, err := this.Exec(query, values...)
+	res, err := that.Exec(query, values...)
 
 	id := int64(0)
 	if err.GetError() == nil && res != nil {
-		id, this.LastErr.err = res.LastInsertId()
-
+		id1, err := res.LastInsertId()
+		that.LastErr.SetError(err)
+		id = id1
 	}
 
 	//如果插入成功，删除缓存
 	if id != 0 {
-		if this.DBCached && this.CacheIns != nil {
-			this.Cache(table+"*", nil)
+		if that.HoTimeCache != nil && table != "cached" {
+			_ = that.HoTimeCache.Db(table+"*", nil)
 		}
 	}
 

dri/aliyun/company.go

@@ -0,0 +1,138 @@
+package aliyun
+
+import (
+	. "../../common"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	//"fmt"
+)
+
+type Company struct {
+	ApiCode string
+	Url     string
+}
+
+func (this *Company) Init(apiCode string) {
+	//"06c6a07e89dd45c88de040ee1489eef7"
+	this.ApiCode = apiCode
+	this.Url = "http://api.81api.com"
+}
+
+// GetCompanyBaseInfo 获取企业基础信息
+func (this *Company) GetCompanyOtherAll(name string) Map {
+
+	res := Map{}
+	data, e := this.GetCompanyPatentsInfo(name) //获取专利信息
+	if e != nil {
+		fmt.Println(e)
+	} else {
+		res["PatentsInfo"] = data.GetMap("data")
+	}
+	data, e = this.GetCompanyOtherCopyrightsInfo(name) //获取其他专利
+	if e != nil {
+		fmt.Println(e)
+	} else {
+		res["OtherCopyrightsInfo"] = data.GetMap("data")
+	}
+	data, e = this.GetCompanyTrademarksInfo(name) //获取商标
+	if e != nil {
+		fmt.Println(e)
+	} else {
+		res["TrademarksInfo"] = data.GetMap("data")
+	}
+	data, e = this.GetCompanySoftwareCopyrightsInfo(name) //获取软著
+	if e != nil {
+		fmt.Println(e)
+	} else {
+		res["SoftwareCopyrightsInfo"] = data.GetMap("data")
+	}
+	data, e = this.GetCompanyProfileTags(name) //获取大数据标签
+	if e != nil {
+		fmt.Println(e)
+	} else {
+		res["ProfileTags"] = data.GetSlice("data")
+	}
+	return res
+}
+
+// GetCompanyBaseInfo 获取企业基础信息
+func (this *Company) GetCompanyBaseInfo(name string) (Map, error) {
+	url := "/getCompanyBaseInfo/"
+
+	body, err := this.basePost(url, name)
+	return ObjToMap(body), err
+}
+
+// GetCompanyPatentsInfo  获取专利信息
+func (this *Company) GetCompanyPatentsInfo(name string) (Map, error) {
+	url := "/getCompanyPatentsInfo/"
+
+	body, err := this.basePost(url, name)
+	return ObjToMap(body), err
+}
+
+//   获取商标信息
+func (this *Company) GetCompanyTrademarksInfo(name string) (Map, error) {
+	url := "/getCompanyTrademarksInfo/"
+
+	body, err := this.basePost(url, name)
+	return ObjToMap(body), err
+}
+
+//   获取软著信息
+func (this *Company) GetCompanySoftwareCopyrightsInfo(name string) (Map, error) {
+	url := "/getCompanySoftwareCopyrightsInfo/"
+
+	body, err := this.basePost(url, name)
+	return ObjToMap(body), err
+}
+
+//   获取其他著作信息
+func (this *Company) GetCompanyOtherCopyrightsInfo(name string) (Map, error) {
+	url := "/getCompanyOtherCopyrightsInfo/"
+
+	body, err := this.basePost(url, name)
+	return ObjToMap(body), err
+}
+
+//   获取大数据标签
+func (this *Company) GetCompanyProfileTags(name string) (Map, error) {
+	url := "/getCompanyProfileTags/"
+	body, err := this.basePost(url, name)
+	return ObjToMap(body), err
+}
+func (this *Company) basePost(url string, name string) (string, error) {
+
+	client := &http.Client{}
+
+	reqest, err := http.NewRequest("GET", this.Url+url+name+"/?isRaiseErrorCode=1", nil)
+
+	if err != nil {
+		fmt.Println("Fatal error ", err.Error())
+		return "", err
+	}
+
+	reqest.Header.Add("Authorization", "APPCODE "+this.ApiCode)
+	response, err := client.Do(reqest)
+	defer response.Body.Close()
+
+	if err != nil {
+		fmt.Println("Fatal error ", err.Error())
+		return "", err
+	}
+
+	body, err := ioutil.ReadAll(response.Body)
+	if err != nil {
+		return "", err
+	}
+	res := string(body)
+	fmt.Println(res)
+	return res, err
+}
+
+var DefaultCompany Company
+
+func init() {
+	DefaultCompany = Company{}
+}

dri/baidu/map.go

@@ -0,0 +1,58 @@
+package baidu
+
+import (
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+)
+
+type BaiduMap struct {
+	Ak  string
+	Url string
+}
+
+func (this *BaiduMap) Init(Ak string) {
+	//"ak=ZeT902EZvVgIoGVWEFK3osUm"
+	this.Ak = Ak
+	this.Url = "https://api.map.baidu.com/place/v2/suggestion?output=json" + "&ak=" + Ak
+	//query
+}
+
+// GetPosition  获取定位列表
+func (this *BaiduMap) GetPosition(name string, region string) (string, error) {
+
+	client := &http.Client{}
+	if region == "" {
+		region = "全国"
+	}
+	reqest, err := http.NewRequest("GET", this.Url+"&query="+url.PathEscape(name)+"&region="+url.PathEscape(region), nil)
+
+	if err != nil {
+		fmt.Println("Fatal error ", err.Error())
+		return "", err
+	}
+	response, err := client.Do(reqest)
+	defer response.Body.Close()
+
+	if err != nil {
+		fmt.Println("Fatal error ", err.Error())
+		return "", err
+	}
+
+	body, err := ioutil.ReadAll(response.Body)
+	if err != nil {
+		return "", err
+	}
+
+	//fmt.Println(string(body))
+
+	return string(body), err
+
+}
+
+var DefaultBaiDuMap BaiduMap
+
+func init() {
+	DefaultBaiDuMap = BaiduMap{}
+}

dri/ddsms/ddsms.go

@@ -18,8 +18,8 @@ type DDY struct {
 
 func (this *DDY) Init(apikey string) {
 	this.ApiKey = apikey
-	this.YzmUrl = "https://api.dingdongcloud.com/v2/sms/single_send"
-	this.TzUrl = "https://api.dingdongcloud.com/v1/sms/notice/multi_send"
+	this.YzmUrl = "https://api.dingdongcloud.com/v2/sms/captcha/send.json"
+	this.TzUrl = "https://api.dingdongcloud.com/v2/sms/notice/send.json"
 }
 
 //发送短信验证码 code验证码如：123456 返回true表示发送成功flase表示发送失败
@@ -34,7 +34,7 @@ func (this *DDY) SendYZM(umoblie string, tpt string, data map[string]string) (bo
 //发送通知
 func (this *DDY) SendTz(umoblie []string, tpt string, data map[string]string) (bool, error) {
 	for k, v := range data {
-		tpt = strings.Replace(tpt, "["+k+"]", v, -1)
+		tpt = strings.Replace(tpt, "{"+k+"}", v, -1)
 	}
 	umobleStr := ""
 	for i, v := range umoblie {
@@ -89,3 +89,9 @@ func (this *DDY) httpsPostForm(url string, data url.Values) (string, error) {
 	return string(body), nil
 
 }
+
+var DefaultDDY DDY
+
+func init() {
+	DefaultDDY = DDY{}
+}

dri/download/download.go

@@ -1,8 +1,8 @@
 package download
 
 import (
+	. "../../common"
 	"bytes"
-	"code.hoteas.com/golang/hotime"
 	"io"
 	"io/ioutil"
 	"net/http"
@@ -10,29 +10,30 @@ import (
 )
 
 //下载文件
-func Down(url, path, name string) bool {
+func Down(url, path, name string, e ...*Error) bool {
 
 	os.MkdirAll(path, os.ModeDir)
-	if hotime.Substr(path, len(path)-1, len(path)) != "/" {
+	if Substr(path, len(path)-1, len(path)) != "/" {
 		path = path + "/"
 	}
 	out, err := os.Create(path + name)
-	e := hotime.Error{}
-	if err != nil {
-		e.SetError(err)
+
+	if err != nil && e[0] != nil {
+		e[0].SetError(err)
 		return false
 	}
 	defer out.Close()
 	resp, err := http.Get(url)
-	if err != nil {
+	if err != nil && e[0] != nil {
+		e[0].SetError(err)
 		return false
 	}
 	defer resp.Body.Close()
 
 	pix, err := ioutil.ReadAll(resp.Body)
 	_, err = io.Copy(out, bytes.NewReader(pix))
-	if err != nil {
-		e.SetError(err)
+	if err != nil && e[0] != nil {
+		e[0].SetError(err)
 		return false
 	}
 	return true

dri/rsa/deencrypt.go

@@ -0,0 +1,143 @@
+package rsa
+
+import (
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/x509"
+	"encoding/asn1"
+	"encoding/pem"
+	"fmt"
+	"os"
+)
+
+func FileGet(path string) []byte {
+	file, err := os.Open(path)
+	if err != nil {
+		panic(err)
+	}
+	defer file.Close()
+	//读取文件的内容
+	info, _ := file.Stat()
+	buf := make([]byte, info.Size())
+	file.Read(buf)
+	return buf
+}
+
+//RSA加密
+// plainText 要加密的数据
+// path 公钥匙文件地址
+func RSA_Encrypt(plainText []byte, buf []byte) []byte {
+	//pem解码
+	block, _ := pem.Decode(buf)
+	//x509解码
+
+	publicKeyInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
+	if err != nil {
+		panic(err)
+	}
+	//类型断言
+	publicKey := publicKeyInterface.(*rsa.PublicKey)
+	//对明文进行加密
+	cipherText, err := rsa.EncryptPKCS1v15(rand.Reader, publicKey, plainText)
+	if err != nil {
+		panic(err)
+	}
+	//返回密文
+	return cipherText
+}
+
+//RSA解密
+// cipherText 需要解密的byte数据
+// path 私钥文件路径
+func RSA_Decrypt(cipherText []byte, buf []byte) []byte {
+
+	//pem解码
+	block, _ := pem.Decode(buf)
+	//X509解码
+	private, err := x509.ParsePKCS8PrivateKey(block.Bytes)
+
+	if err != nil {
+		panic(err)
+	}
+	//对密文进行解密
+	//plainText,_:=rsa.DecryptPKCS1v15(rand.Reader,privateKey,cipherText)
+
+	v, err := rsa.DecryptPKCS1v15(rand.Reader, private.(*rsa.PrivateKey), cipherText)
+	//返回明文
+	return v
+}
+func MarshalPKCS8PrivateKey(key *rsa.PrivateKey) []byte {
+	info := struct {
+		Version             int
+		PrivateKeyAlgorithm []asn1.ObjectIdentifier
+		PrivateKey          []byte
+	}{}
+	info.Version = 0
+	info.PrivateKeyAlgorithm = make([]asn1.ObjectIdentifier, 1)
+	info.PrivateKeyAlgorithm[0] = asn1.ObjectIdentifier{1, 2, 840, 113549, 1, 1, 1}
+	info.PrivateKey = x509.MarshalPKCS1PrivateKey(key)
+
+	k, err := asn1.Marshal(info)
+	if err != nil {
+		panic(err.Error())
+	}
+	return k
+}
+
+func Demo() {
+	//生成密钥对，保存到文件
+	GenerateRSAKey(2048, "./")
+	//加密
+	data := []byte("hello world")
+	encrypt := RSA_Encrypt(data, FileGet("public.pem"))
+	fmt.Println(string(encrypt))
+
+	// 解密
+	decrypt := RSA_Decrypt(encrypt, FileGet("private.pem"))
+	fmt.Println(string(decrypt))
+}
+
+//生成RSA私钥和公钥，保存到文件中
+// bits 证书大小
+func GenerateRSAKey(bits int, path string) {
+	//GenerateKey函数使用随机数据生成器random生成一对具有指定字位数的RSA密钥
+	//Reader是一个全局、共享的密码用强随机数生成器
+	privateKey, err := rsa.GenerateKey(rand.Reader, bits)
+	if err != nil {
+		panic(err)
+	}
+	//保存私钥
+	//通过x509标准将得到的ras私钥序列化为ASN.1 的 DER编码字符串
+	X509PrivateKey := x509.MarshalPKCS1PrivateKey(privateKey)
+	//使用pem格式对x509输出的内容进行编码
+	//创建文件保存私钥
+	privateFile, err := os.Create(path + "private.pem")
+	if err != nil {
+		panic(err)
+	}
+	defer privateFile.Close()
+	//构建一个pem.Block结构体对象
+	privateBlock := pem.Block{Type: "RSA Private Key", Bytes: X509PrivateKey}
+	//将数据保存到文件
+	pem.Encode(privateFile, &privateBlock)
+
+	//保存公钥
+	//获取公钥的数据
+	publicKey := privateKey.PublicKey
+	//X509对公钥编码
+	X509PublicKey, err := x509.MarshalPKIXPublicKey(&publicKey)
+	if err != nil {
+		panic(err)
+	}
+	//pem格式编码
+	//创建用于保存公钥的文件
+	publicFile, err := os.Create(path + "public.pem")
+	if err != nil {
+		panic(err)
+	}
+	defer publicFile.Close()
+	//创建一个pem.Block结构体对象
+	publicBlock := pem.Block{Type: "RSA Public Key", Bytes: X509PublicKey}
+	//保存到文件
+	pem.Encode(publicFile, &publicBlock)
+}

dri/tencent/company.go

@@ -0,0 +1,103 @@
+package tencent
+
+import (
+	. "../../common"
+	"crypto/hmac"
+	"crypto/sha1"
+	"encoding/base64"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	gourl "net/url"
+
+	"strings"
+	"time"
+)
+
+func calcAuthorization(source string, secretId string, secretKey string) (auth string, datetime string, err error) {
+
+	timeLocation, _ := time.LoadLocation("Etc/GMT")
+	datetime = time.Now().In(timeLocation).Format("Mon, 02 Jan 2006 15:04:05 GMT")
+	signStr := fmt.Sprintf("x-date: %s\nx-source: %s", datetime, source)
+
+	// hmac-sha1
+	mac := hmac.New(sha1.New, []byte(secretKey))
+	mac.Write([]byte(signStr))
+	sign := base64.StdEncoding.EncodeToString(mac.Sum(nil))
+
+	auth = fmt.Sprintf("hmac id=\"%s\", algorithm=\"hmac-sha1\", headers=\"x-date x-source\", signature=\"%s\"",
+		secretId, sign)
+
+	return auth, datetime, nil
+}
+
+func urlencode(params map[string]string) string {
+	var p = gourl.Values{}
+	for k, v := range params {
+		p.Add(k, v)
+	}
+	return p.Encode()
+}
+
+func GetCompany(secretId, secretKey, name string) Map {
+	// 云市场分配的密钥Id
+	//secretId := "xxxx"
+	//// 云市场分配的密钥Key
+	//secretKey := "xxxx"
+	source := "market"
+
+	// 签名
+	auth, datetime, _ := calcAuthorization(source, secretId, secretKey)
+
+	// 请求方法
+	method := "GET"
+	// 请求头
+	headers := map[string]string{"X-Source": source, "X-Date": datetime, "Authorization": auth}
+
+	// 查询参数
+	queryParams := make(map[string]string)
+	queryParams["keyword"] = name
+	// body参数
+	bodyParams := make(map[string]string)
+
+	// url参数拼接
+	url := "https://service-3jnh3ku8-1256140209.gz.apigw.tencentcs.com/release/business4/geet"
+	if len(queryParams) > 0 {
+		url = fmt.Sprintf("%s?%s", url, urlencode(queryParams))
+	}
+
+	bodyMethods := map[string]bool{"POST": true, "PUT": true, "PATCH": true}
+	var body io.Reader = nil
+	if bodyMethods[method] {
+		body = strings.NewReader(urlencode(bodyParams))
+		headers["Content-Type"] = "application/x-www-form-urlencoded"
+	}
+
+	client := &http.Client{
+		Timeout: 5 * time.Second,
+	}
+	request, err := http.NewRequest(method, url, body)
+	if err != nil {
+		fmt.Println(err)
+		return nil
+	}
+	for k, v := range headers {
+		request.Header.Set(k, v)
+	}
+	response, err := client.Do(request)
+	if err != nil {
+		fmt.Println(err)
+		return nil
+	}
+	defer response.Body.Close()
+
+	bodyBytes, err := ioutil.ReadAll(response.Body)
+	if err != nil {
+		fmt.Println(err)
+		return nil
+	}
+	res := string(bodyBytes)
+	fmt.Println(res)
+	return ObjToMap(res)
+}

dri/tencent/tencent.go

@@ -0,0 +1,88 @@
+package tencent
+
+import (
+	"fmt"
+	"github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common"
+	"github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/errors"
+	"github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/profile"
+	ocr "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/ocr/v20181119"
+)
+
+var credential = common.NewCredential(
+	"AKIDOgT8cKCQksnY7yKATaYO7j9ORJzSYohP",
+	"GNXgjdN4czA9ya0FNMApVJzTmsmU0KSN",
+)
+
+func OCRCOMPANY(base64Str string) string {
+
+	cpf := profile.NewClientProfile()
+	cpf.HttpProfile.Endpoint = "ocr.tencentcloudapi.com"
+	client, _ := ocr.NewClient(credential, "ap-guangzhou", cpf)
+
+	request := ocr.NewBizLicenseOCRRequest()
+
+	//request.ImageUrl = common.StringPtr("https://img0.baidu.com/it/u=2041013181,3227632688&fm=26&fmt=auto")
+	request.ImageBase64 = common.StringPtr(base64Str)
+
+	response, err := client.BizLicenseOCR(request)
+	if _, ok := err.(*errors.TencentCloudSDKError); ok {
+		fmt.Println("An API error has returned: %s", err)
+		return ""
+	}
+	if err != nil {
+		fmt.Println("An API error has returned: %s", err)
+		return ""
+	}
+	//fmt.Printf("%s", response.ToJsonString())
+
+	return response.ToJsonString()
+}
+
+func OCR(base64Str string) string {
+
+	cpf := profile.NewClientProfile()
+	cpf.HttpProfile.Endpoint = "ocr.tencentcloudapi.com"
+	client, _ := ocr.NewClient(credential, "ap-guangzhou", cpf)
+
+	request := ocr.NewGeneralAccurateOCRRequest()
+
+	//request.ImageUrl = common.StringPtr("https://img0.baidu.com/it/u=2041013181,3227632688&fm=26&fmt=auto")
+	request.ImageBase64 = common.StringPtr(base64Str)
+
+	response, err := client.GeneralAccurateOCR(request)
+	if _, ok := err.(*errors.TencentCloudSDKError); ok {
+		fmt.Println("An API error has returned: %s", err)
+		return ""
+	}
+	if err != nil {
+		fmt.Println("An API error has returned: %s", err)
+		return ""
+	}
+	//fmt.Printf("%s", response.ToJsonString())
+
+	return response.ToJsonString()
+}
+
+func Qrcode(base64Str string) string {
+
+	cpf := profile.NewClientProfile()
+	cpf.HttpProfile.Endpoint = "ocr.tencentcloudapi.com"
+	client, _ := ocr.NewClient(credential, "ap-guangzhou", cpf)
+
+	request := ocr.NewQrcodeOCRRequest()
+
+	request.ImageBase64 = common.StringPtr(base64Str)
+
+	response, err := client.QrcodeOCR(request)
+	if _, ok := err.(*errors.TencentCloudSDKError); ok {
+		fmt.Println("An API error has returned: %s", err)
+		return ""
+	}
+	if err != nil {
+		fmt.Println("An API error has returned: %s", err)
+		return ""
+	}
+	//fmt.Printf("%s", response.ToJsonString())
+
+	return response.ToJsonString()
+}

dri/upload/upload.go

@@ -1,7 +1,7 @@
 package upload
 
 import (
-	"code.hoteas.com/golang/hotime"
+	. "../../common"
 	"errors"
 	"io"
 	"mime/multipart"
@@ -50,7 +50,7 @@ func (this *Upload) UpFile(Request *http.Request, fieldName, savefilepath, saveP
 				}
 			}
 		}
-		filename := time.Unix(int64(t), 0).Format("2006-01-02-15-22-25") + hotime.ObjToStr(hotime.Rand(6))
+		filename := time.Unix(int64(t), 0).Format("2006-01-02-15-22-25") + ObjToStr(Rand(6))
 		filePath = path + "/" + filename + this.Path
 	} else {
 		filePath = savePath

error.go

@@ -1,25 +0,0 @@
-package hotime
-
-//框架层处理错误
-type Error struct {
-	error
-	err error
-}
-
-func (this *Error) GetError() error {
-
-	return this.error
-
-}
-
-func (this *Error) SetError(err error, loglevel ...int) {
-
-	this.error = nil
-	if err == nil {
-		this.error = err
-		this.err = err
-		return
-	}
-	this.error = err
-	return
-}

example/config/config.json

@@ -0,0 +1,56 @@
+{
+	"avatarPath": "avatar/2006/01/02/",
+	"cache": {
+		"db": {
+			"db": false,
+			"session": true
+		},
+		"memory": {
+			"db": true,
+			"session": true,
+			"timeout": 7200
+		}
+	},
+	"codeConfig": {
+		"admin": "config/app.json"
+	},
+	"codeConfig1": {
+		"admin": {
+			"config": "config/app.json",
+			"package": "admin",
+			"rule": "config/rule.json"
+		}
+	},
+	"crossDomain": "auto",
+	"db": {
+		"mysql": {
+			"host": "192.168.6.253",
+			"name": "iedc_dev",
+			"password": "dasda8454456",
+			"port": "3306",
+			"prefix": "",
+			"user": "root"
+		}
+	},
+	"defFile": [
+		"index.html",
+		"index.htm"
+	],
+	"error": {
+		"1": "内部系统异常",
+		"2": "访问权限异常",
+		"3": "请求参数异常",
+		"4": "数据处理异常",
+		"5": "数据结果异常"
+	},
+	"imgPath": "img/2006/01/02/",
+	"mode": 3,
+	"port": "8081",
+	"sessionName": "HOTIME",
+	"smsKey": "b0eb4bf0198b9983cffcb85b69fdf4fa",
+	"smsLogin": "【政企超链接】您的验证码为：{code}，请在5分钟内使用，切勿将验证码泄露于他人，如非本人操作请忽略。",
+	"tpt": "tpt",
+	"wechatAppID": "wx2edb802f5c3ae1ae",
+	"wechatAppSecret": "4ff97e523c3de6bad47051b568522386",
+	"wxFilePath": "wxfile/2006/01/02/"
+}

example/config/configNote.json

@@ -0,0 +1,72 @@
+{
+	"cache": {
+		"db": {
+			"db": "默认false，非必须，缓存数据库，启用后能减少数据库的读写压力",
+			"session": "默认true，非必须，缓存web session，同时缓存session保持的用户缓存",
+			"timeout": "默认60 * 60 * 24 * 30，非必须，过期时间，超时自动删除"
+		},
+		"memory": {
+			"db": "默认true，非必须，缓存数据库，启用后能减少数据库的读写压力",
+			"session": "默认true，非必须，缓存web session，同时缓存session保持的用户缓存",
+			"timeout": "默认60 * 60 * 2，非必须，过期时间，超时自动删除"
+		},
+		"redis": {
+			"db": "默认true，非必须，缓存数据库，启用后能减少数据库的读写压力",
+			"host": "默认服务ip：127.0.0.1，必须，如果需要使用redis服务时配置，",
+			"password": "默认密码空，必须，如果需要使用redis服务时配置，默认密码空",
+			"port": "默认服务端口：6379，必须，如果需要使用redis服务时配置，",
+			"session": "默认true，非必须，缓存web session，同时缓存session保持的用户缓存",
+			"timeout": "默认60 * 60 * 24 * 15，非必须，过期时间，超时自动删除"
+		},
+		"注释": "可配置memory，db，redis，默认启用memory，默认优先级为memory\u003eredis\u003edb,memory与数据库缓存设置项一致，缓存数据填充会自动反方向反哺，加入memory缓存过期将自动从redis更新，但memory永远不会更新redis，如果是集群建议不要开启memory，配置即启用"
+	},
+	"codeConfig": {
+		"packageName": "默认无，必须，包名称以及应用名，生成代码的配置文件地址，比如config/app.json，数据库有更新时自动更新配置文件以及对应的生成文件",
+		"注释": "配置即启用，非必须，默认无"
+	},
+	"crossDomain": "默认空 非必须，空字符串为不开启，如果需要跨域设置，auto为智能开启所有网站允许跨域，http://www.baidu.com为指定域允许跨域",
+	"db": {
+		"mysql": {
+			"host": "默认127.0.0.1，必须，数据库ip地址",
+			"name": "默认test，必须，数据库名称",
+			"password": "默认root，必须，数据库密码",
+			"port": "默认3306，必须，数据库端口",
+			"prefix": "默认空，非必须，数据表前缀",
+			"slave": {
+				"host": "默认127.0.0.1，必须，数据库ip地址",
+				"name": "默认test，必须，数据库名称",
+				"password": "默认root，必须，数据库密码",
+				"port": "默认3306，必须，数据库端口",
+				"user": "默认root，必须，数据库用户名",
+				"注释": "从数据库配置，mysql里配置slave项即启用主从读写，减少数据库压力"
+			},
+			"user": "默认root，必须，数据库用户名",
+			"注释": "除prefix及主从数据库slave项，其他全部必须"
+		},
+		"sqlite": {
+			"path": "默认config/data.db，必须，数据库位置"
+		},
+		"注释": "配置即启用，非必须，默认使用sqlite数据库"
+	},
+	"defFile": "默认访问index.html或者index.htm文件，必须，默认访问文件类型",
+	"error": {
+		"1": "内部系统异常，在环境配置，文件访问权限等基础运行环境条件不足造成严重错误时使用",
+		"2": "访问权限异常，没有登录或者登录异常等时候使用",
+		"3": "请求参数异常，request参数不满足要求，比如参数不足，参数类型错误，参数不满足要求等时候使用",
+		"4": "数据处理异常,数据库操作或者三方请求返回的结果非正常结果，比如数据库突然中断等时候使用",
+		"5": "数据结果异常，一般用于无法给出response要求的格式要求下使用，比如response需要的是string格式但你只能提供int数据时",
+		"注释": "web服务内置错误提示，自定义异常建议10开始"
+	},
+	"logFile": "无默认，非必须，如果需要存储日志文件时使用，保存格式为:a/b/c/20060102150405.txt,将生成：a/b/c/年月日时分秒.txt，按需设置",
+	"logLevel": "默认0，必须，0关闭，1打印，日志等级",
+	"mode": "默认0,非必须，0生产模式，1，测试模式，2开发模式，3内嵌代码模式，在开发模式下会显示更多的数据用于开发测试，并能够辅助研发，自动生成配置文件、代码等功能,web无缓存，数据库不启用缓存",
+	"modeRouterStrict": "默认false,必须，路由严格模式false,为大小写忽略必须匹配，true必须大小写匹配",
+	"port": "默认80，必须，web服务开启Http端口，0为不启用http服务,默认80",
+	"sessionName": "默认HOTIME，必须，设置session的cookie名",
+	"tlsCert": "默认空，非必须，https证书",
+	"tlsKey": "默认空，非必须，https密钥",
+	"tlsPort": "默认空，非必须，web服务https端口，0为不启用https服务",
+	"tpt": "默认tpt，必须，web静态文件目录，默认为程序目录下tpt目录",
+	"webConnectLogFile": "无默认，非必须，webConnectLogShow开启之后才能使用，如果需要存储日志文件时使用，保存格式为:a/b/c/20060102150405.txt,将生成：a/b/c/年月日时分秒.txt，按需设置",
+	"webConnectLogShow": "默认true，非必须，访问日志如果需要web访问链接、访问ip、访问时间打印，false为关闭true开启此功能"
+}

example/main.go

@@ -1,106 +1,15 @@
 package main
 
 import (
-	"code.hoteas.com/golang/hotime"
-	"code.hoteas.com/golang/hotime/tools/db"
+	"../../hotime"
+	//"../dri/aliyun"
 	"fmt"
-	//"go.hoteas.com/hotime/cache"
-	"golang.org/x/net/websocket"
 	"time"
-	//"go.hoteas.com/hotime/cache"
 )
 
 func main() {
-
-	appIns := hotime.Application{}
-
-	appIns.SetConnectListener(func(context *hotime.Context) bool {
-		//fmt.Println(context.HandlerStr + time.Now().Format(" 2006-01-02 15:04 ") + hotime.Substr(context.Req.RemoteAddr, 0, strings.Index(context.Req.RemoteAddr, ":")))
-
-		//this.HandlerStr = "/test.html"
-		return true
-	})
-
-	//手动模式，
-	appIns.SetConfig("example/config/config.json")
-	//redis缓存接入
-	//ca:=hotime.CacheIns(&cache.CacheRedis{Host:appIns.Config.GetString("redisHost"),Pwd:appIns.Config.GetString("redisPwd"),Time:appIns.Config.GetCeilInt64("cacheLongTime")})
-	//ca.Cache("xyzm","dasdas")
-	//ca.Cache("xyzn","dasdas")
-	//ca.Cache("xyzo","dasdas")
-	//ca.Cache("xyz*",nil)
-	//fmt.Println(ca.Cache("xyzm").Data)
-	//mysql
-	//mysql.SetDB(&appIns)
-	//自动选择数据库
-	db.SetDB(&appIns)
-
-	//appIns.SetConnectDB(func(err ...*hotime.Error) *sql.DB {
-	//	query := appIns.Config.GetString("dbUser") + ":" + appIns.Config.GetString("dbPwd") +
-	//		"@tcp(" + appIns.Config.GetString("dbHost") + ":" + appIns.Config.GetString("dbPort") + ")/" + appIns.Config.GetString("dbName") + "?charset=utf8"
-	//	DB, e := sql.Open("mysql", query)
-	//	if e != nil && len(err) != 0 {
-	//		err[0].SetError(e)
-	//	}
-	//	return DB
-	//})
-	//内存缓存数据库数据，错误则删除
-	//	appIns.Db.CacheIns=hotime.CacheIns(&hotime.CacheMemory{})
-
-	appIns.SetSession(hotime.CacheIns(&hotime.CacheMemory{}), hotime.CacheIns(&hotime.CacheDb{Db: &appIns.Db, Time: appIns.Config.GetInt64("cacheTime")}))
-	appIns.SetCache(hotime.CacheIns(&hotime.CacheMemory{}))
-
-	//快捷模式
-	//appIns.SetDefault(func(err ...*hotime.Error) *sql.DB {
-	//	query := appIns.Config.GetString("dbUser") + ":" + appIns.Config.GetString("dbPwd") +
-	//		"@tcp(" + appIns.Config.GetString("dbHost") + ":" + appIns.Config.GetString("dbPort") + ")/" + appIns.Config.GetString("dbName") + "?charset=utf8"
-	//	DB, e := sql.Open("mysql", query)
-	//	if e != nil && len(err) != 0 {
-	//		err[0].SetError(e)
-	//	}
-	//	return DB
-	//})
-
-	appIns.Run(hotime.Router{
-		"app": hotime.Proj{
-			"index": hotime.Ctr{
-				"test": func(this *hotime.Context) {
-					fmt.Println(this.Db.GetTag())
-					//x:=this.Db.Action(func(db hotime.HoTimeDB) bool {
-					//
-					//	db.Insert("user",hotime.Map{"unickname":"dasdas"})
-					//
-					//	return true
-					//})
-					hotime.LogError("dasdasdasdasdas")
-					this.Display(5, "dsadas")
-				},
-				"websocket": func(this *hotime.Context) {
-					hdler := websocket.Handler(func(ws *websocket.Conn) {
-						for true {
-							msg := make([]byte, 5120)
-							n, err := ws.Read(msg)
-							go func() {
-								time.Sleep(time.Second * 5)
-								ws.Write([]byte("dsadasdasgregergrerge"))
-
-							}()
-							if err != nil {
-								return
-							}
-							fmt.Printf("Receive: %s\n", msg[:n])
-
-							send_msg := "[" + string(msg[:n]) + "]"
-							m, err := ws.Write([]byte(send_msg))
-							if err != nil {
-								return
-							}
-							fmt.Printf("Send: %s\n", msg[:m])
-						}
-					})
-					hdler.ServeHTTP(this.Resp, this.Req)
-				},
-			},
-		},
-	})
+	date, _ := time.Parse("2006-01-02 15:04", time.Now().Format("2006-01-02")+" 14:00")
+	fmt.Println(date, date.Unix())
+	//fmt.Println("0123456"[1:7])
+	appIns := hotime.Init("config/config.json")
 }

example/tpt/index.html

@@ -1,28 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-    <meta charset="UTF-8"/>
-    <title>Sample of websocket with golang</title>
-    <script src="http://apps.bdimg.com/libs/jquery/2.1.4/jquery.min.js"></script>
-
-    <script>
-        $(function() {
-            var ws = new WebSocket("ws://localhost:8080/app/index/websocket");
-            ws.onmessage = function(e) {
-
-                $('<li>').text(e.data).appendTo($ul);
-            };
-            var $ul = $('#msg-list');
-            $('#sendBtn').click(function(){
-                var data = $('#name').val();
-                ws.send(data);
-            });
-        });
-    </script>
-</head>
-<body>
-<input id="name" type="text"/>
-<input type="button" id="sendBtn" value="send"/>
-<ul id="msg-list"></ul>
-</body>
-</html>

go.mod

@@ -1,10 +1,13 @@
-go 1.14
+module code.hoteas.com/golang/hotime
+
+go 1.16
 
 require (
-	github.com/garyburd/redigo v1.6.0
-	github.com/go-sql-driver/mysql v1.5.0
-	github.com/mattn/go-sqlite3 v2.0.3+incompatible
-	golang.org/x/net v0.0.0-20200425230154-ff2c4b7c35a0
+	github.com/garyburd/redigo v1.6.3
+	github.com/go-sql-driver/mysql v1.6.0
+	github.com/mattn/go-sqlite3 v1.14.12
+	github.com/sirupsen/logrus v1.8.1
+	github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common v1.0.364
+	github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/ocr v1.0.364
+	golang.org/x/net v0.0.0-20220225172249-27dd8689420f
 )
-
-module code.hoteas.com/golang/hotime

go.sum

@@ -1,13 +1,27 @@
-github.com/garyburd/redigo v1.6.0 h1:0VruCpn7yAIIu7pWVClQC8wxCJEcG3nyzpMSHKi1PQc=
-github.com/garyburd/redigo v1.6.0/go.mod h1:NR3MbYisc3/PwhQ00EMzDiPmrwpPxAn5GI05/YaO1SY=
-github.com/go-sql-driver/mysql v1.5.0 h1:ozyZYNQW3x3HtqT1jira07DN2PArx2v7/mN66gGcHOs=
-github.com/go-sql-driver/mysql v1.5.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
-github.com/mattn/go-sqlite3 v1.13.0 h1:LnJI81JidiW9r7pS/hXe6cFeO5EXNq7KbfvoJLRI69c=
-github.com/mattn/go-sqlite3 v2.0.3+incompatible h1:gXHsfypPkaMZrKbD5209QV9jbUTJKjyR5WD3HYQSd+U=
-github.com/mattn/go-sqlite3 v2.0.3+incompatible/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/net v0.0.0-20200425230154-ff2c4b7c35a0 h1:Jcxah/M+oLZ/R4/z5RzfPzGbPXnVDPkEDtf2JnuxN+U=
-golang.org/x/net v0.0.0-20200425230154-ff2c4b7c35a0/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/garyburd/redigo v1.6.3 h1:HCeeRluvAgMusMomi1+6Y5dmFOdYV/JzoRrrbFlkGIc=
+github.com/garyburd/redigo v1.6.3/go.mod h1:rTb6epsqigu3kYKBnaF028A7Tf/Aw5s0cqA47doKKqw=
+github.com/go-sql-driver/mysql v1.6.0 h1:BCTh4TKNUYmOmMUcQ3IipzF5prigylS7XXjEkfCHuOE=
+github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
+github.com/mattn/go-sqlite3 v1.14.12 h1:TJ1bhYJPV44phC+IMu1u2K/i5RriLTPe+yc68XDJ1Z0=
+github.com/mattn/go-sqlite3 v1.14.12/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/sirupsen/logrus v1.8.1 h1:dJKuHgqk1NNQlqoA6BTlM1Wf9DOH3NBjQyu0h9+AZZE=
+github.com/sirupsen/logrus v1.8.1/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
+github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common v1.0.364 h1:X1Jws4XqrTH+p7FBQ7BpjW4qFXObKHWm0/XhW/GvqRs=
+github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common v1.0.364/go.mod h1:7sCQWVkxcsR38nffDW057DRGk8mUjK1Ing/EFOK8s8Y=
+github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/ocr v1.0.364 h1:kbor60vo37v7Hu+i17gooox9Rw281fVHNna8zwtDG1w=
+github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/ocr v1.0.364/go.mod h1:LeIUBOLhc+Y5YCEpZrULPD9lgoXXV4/EmIcoEvmHz9c=
+golang.org/x/net v0.0.0-20220225172249-27dd8689420f h1:oA4XRj0qtSt8Yo1Zms0CUlsT3KG69V2UGQWPBxujDmc=
+golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e h1:fLOSk5Q00efkSvAm+4xcoXD+RRmLmmulPn5I3Y9F2EM=
+golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=

log/logrus.go

@@ -0,0 +1,117 @@
+package log
+
+import (
+	"fmt"
+	log "github.com/sirupsen/logrus"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"time"
+)
+
+func GetLog(path string, showCodeLine bool) *log.Logger {
+
+	hook := MyHook{
+		Field: "line",
+		Skip:  5,
+		Path:  path, ShowCodeLine: showCodeLine,
+	}
+
+	loger := log.New()
+	loger.SetFormatter(&log.TextFormatter{})
+	loger.AddHook(&hook)
+	return loger
+}
+
+// MyHook ...
+type MyHook struct {
+	Path         string //存储日志的位置
+	ShowCodeLine bool   //输出代码文件名称和日志行
+	Field        string
+	Skip         int
+	levels       []log.Level
+}
+
+// Levels 只定义 error 和 panic 等级的日志,其他日志等级不会触发 hook
+func (that *MyHook) Levels() []log.Level {
+	return log.AllLevels
+}
+
+// Fire 将异常日志写入到指定日志文件中
+func (that *MyHook) Fire(entry *log.Entry) error {
+	if that.ShowCodeLine {
+		entry.Data[that.Field] = findCaller(that.Skip)
+	}
+	//不需要存储到文件
+	if that.Path == "" {
+		return nil
+	}
+	//存储到文件
+	logFilePath := time.Now().Format(that.Path)
+
+	err := os.MkdirAll(filepath.Dir(logFilePath), os.ModeAppend)
+	if err != nil {
+		return err
+	}
+	//os.Create(logFilePath)
+	f, err := os.OpenFile(logFilePath, os.O_APPEND|os.O_CREATE, 0644)
+	if err != nil {
+		return err
+	}
+	bte, _ := entry.Bytes()
+	_, err = f.Write(bte)
+	if err != nil {
+		return err
+	}
+
+	err = f.Close()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// 对caller进行递归查询, 直到找到非logrus包产生的第一个调用.
+// 因为filename我获取到了上层目录名, 因此所有logrus包的调用的文件名都是 logrus/...
+// 因此通过排除logrus开头的文件名, 就可以排除所有logrus包的自己的函数调用
+func findCaller(skip int) string {
+	file := ""
+	line := 0
+	for i := 0; i < 10; i++ {
+		file, line = getCaller(skip + i)
+		if !strings.HasPrefix(file, "logrus") {
+
+			if file == "common/error.go" {
+				file, line = getCaller(skip + i + 1)
+			}
+			break
+		}
+	}
+	return fmt.Sprintf("%s:%d", file, line)
+}
+
+// 这里其实可以获取函数名称的: fnName := runtime.FuncForPC(pc).Name()
+// 但是我觉得有 文件名和行号就够定位问题, 因此忽略了caller返回的第一个值:pc
+// 在标准库log里面我们可以选择记录文件的全路径或者文件名, 但是在使用过程成并发最合适的,
+// 因为文件的全路径往往很长, 而文件名在多个包中往往有重复, 因此这里选择多取一层, 取到文件所在的上层目录那层.
+func getCaller(skip int) (string, int) {
+	_, file, line, ok := runtime.Caller(skip)
+	//fmt.Println(file)
+	//fmt.Println(line)
+	if !ok {
+		return "", 0
+	}
+	n := 0
+	for i := len(file) - 1; i > 0; i-- {
+		if file[i] == '/' {
+			n++
+			if n >= 2 {
+				file = file[i+1:]
+				break
+			}
+		}
+	}
+	return file, line
+}

map.go

@@ -1,155 +0,0 @@
-package hotime
-
-import (
-	"encoding/json"
-	"errors"
-	"reflect"
-)
-
-//hotime的常用map
-type Map map[string]interface{}
-
-//获取string
-func (this Map) GetString(key string, err ...*Error) string {
-
-	if len(err) != 0 {
-		err[0].SetError(nil)
-	}
-	return ObjToStr((this)[key])
-
-}
-
-func (this *Map) Pointer() *Map {
-
-	return this
-}
-
-//增加接口
-func (this Map) Put(key string, value interface{}) {
-	//if this==nil{
-	//	this=Map{}
-	//}
-	this[key] = value
-}
-
-//删除接口
-func (this Map) Delete(key string) {
-	delete(this, key)
-
-}
-
-//获取Int
-func (this Map) GetInt(key string, err ...*Error) int {
-	v := ObjToInt((this)[key], err...)
-
-	return v
-
-}
-
-//获取Int
-func (this Map) GetInt64(key string, err ...*Error) int64 {
-	v := ObjToInt64((this)[key], err...)
-	return v
-
-}
-
-//获取向上取整Int64
-func (this Map) GetCeilInt64(key string, err ...*Error) int64 {
-	v := ObjToCeilInt64((this)[key], err...)
-	return v
-
-}
-
-//获取向上取整Int
-func (this Map) GetCeilInt(key string, err ...*Error) int {
-	v := ObjToCeilInt((this)[key], err...)
-	return v
-
-}
-
-//获取向上取整float64
-func (this Map) GetCeilFloat64(key string, err ...*Error) float64 {
-	v := ObjToCeilFloat64((this)[key], err...)
-	return v
-
-}
-
-//获取Float64
-func (this Map) GetFloat64(key string, err ...*Error) float64 {
-
-	v := ObjToFloat64((this)[key], err...)
-
-	return v
-
-}
-
-func (this Map) GetSlice(key string, err ...*Error) Slice {
-
-	//var v Slice
-	v := ObjToSlice((this)[key], err...)
-
-	return v
-
-}
-
-func (this Map) GetMap(key string, err ...*Error) Map {
-	//var data Slice
-
-	v := ObjToMap((this)[key], err...)
-
-	return v
-
-}
-
-func (this Map) Get(key string, err ...*Error) interface{} {
-
-	if v, ok := (this)[key]; ok {
-		return v
-	}
-	e := errors.New("没有存储key及对应的数据")
-
-	if len(err) != 0 {
-		err[0].SetError(e)
-
-	}
-	return nil
-}
-
-//请传递指针过来
-func (this Map) ToStruct(stct interface{}) {
-
-	data := reflect.ValueOf(stct).Elem()
-	for k, v := range this {
-		ks := StrFirstToUpper(k)
-		dkey := data.FieldByName(ks)
-		if !dkey.IsValid() {
-			continue
-		}
-		switch dkey.Type().String() {
-		case "int":
-			dkey.SetInt(this.GetInt64(k))
-		case "int64":
-			dkey.Set(reflect.ValueOf(this.GetInt64(k)))
-		case "float64":
-			dkey.Set(reflect.ValueOf(this.GetFloat64(k)))
-		case "string":
-			dkey.Set(reflect.ValueOf(this.GetString(k)))
-		case "interface{}":
-			dkey.Set(reflect.ValueOf(v))
-		}
-	}
-
-}
-
-func (this Map) ToJsonString() string {
-	return ObjToStr(this)
-
-}
-
-func (this Map) JsonToMap(jsonStr string, err ...*Error) {
-	e := json.Unmarshal([]byte(jsonStr), &this)
-	if e != nil && len(err) != 0 {
-		err[0].SetError(e)
-	}
-
-}

obj.go

@@ -1,93 +0,0 @@
-package hotime
-
-//对象封装方便取用
-type Obj struct {
-	Data interface{}
-	contextBase
-}
-
-func (this *Obj) Put(data interface{}) {
-	this.Data = data
-}
-
-func (this *Obj) ToInt(err ...Error) int {
-	if len(err) != 0 {
-		this.Error = err[0]
-	}
-	return ObjToInt(this.Data, &this.Error)
-}
-
-func (this *Obj) ToInt64(err ...Error) int64 {
-	if len(err) != 0 {
-		this.Error = err[0]
-	}
-	return ObjToInt64(this.Data, &this.Error)
-}
-
-func (this *Obj) ToFloat64(err ...Error) float64 {
-	if len(err) != 0 {
-		this.Error = err[0]
-	}
-	return ObjToFloat64(this.Data, &this.Error)
-}
-
-//获取向上取整float64
-func (this *Obj) ToCeilFloat64(err ...*Error) float64 {
-	if len(err) != 0 {
-		this.Error = *err[0]
-	}
-	v := ObjToCeilFloat64(this.Data, err...)
-	return v
-
-}
-
-func (this *Obj) ToStr() string {
-
-	return ObjToStr(this.Data)
-}
-
-func (this *Obj) ToMap(err ...Error) Map {
-	if len(err) != 0 {
-		this.Error = err[0]
-	}
-	return ObjToMap(this.Data, &this.Error)
-}
-
-func (this *Obj) ToSlice(err ...Error) Slice {
-	if len(err) != 0 {
-		this.Error = err[0]
-	}
-	return ObjToSlice(this.Data, &this.Error)
-}
-
-func (this *Obj) ToMapArray(err ...Error) []Map {
-	if len(err) != 0 {
-		this.Error = err[0]
-	}
-	return ObjToMapArray(this.Data, &this.Error)
-}
-
-func (this *Obj) ToObj() interface{} {
-
-	return this.Data
-}
-
-//获取向上取整Int64
-func (this *Obj) ToCeilInt64(err ...*Error) int64 {
-	if len(err) != 0 {
-		this.Error = *err[0]
-	}
-	v := ObjToCeilInt64(this.Data, err...)
-	return v
-
-}
-
-//获取向上取整Int
-func (this *Obj) ToCeilInt(err ...*Error) int {
-	if len(err) != 0 {
-		this.Error = *err[0]
-	}
-	v := ObjToCeilInt(this.Data, err...)
-	return v
-
-}

session.go

@@ -1,71 +1,56 @@
 package hotime
 
+import (
+	. "./cache"
+	. "./common"
+)
+
 //session对象
 type SessionIns struct {
-	ShortCache CacheIns
-	LongCache  CacheIns
-	SessionId  string
+	*HoTimeCache
+	SessionId string
 	Map
-	contextBase
+	ContextBase
 }
 
-func (this *SessionIns) set() {
-
-	if this.ShortCache != nil {
-		this.ShortCache.Cache(HEAD_SESSION_ADD+this.SessionId, this.Map)
-	}
-	if this.LongCache != nil {
-		this.LongCache.Cache(HEAD_SESSION_ADD+this.SessionId, this.Map)
-	}
-
+func (that *SessionIns) set() {
+	that.HoTimeCache.Session(HEAD_SESSION_ADD+that.SessionId, that.Map)
 }
 
-func (this *SessionIns) Session(key string, data ...interface{}) *Obj {
+func (that *SessionIns) Session(key string, data ...interface{}) *Obj {
 
-	if this.Map == nil {
-		this.get()
+	if that.Map == nil {
+		that.get()
 	}
 
 	if len(data) != 0 {
 		if data[0] == nil {
-			delete(this.Map, key)
-			this.set()
+			delete(that.Map, key)
+			that.set()
 		} else {
-			this.Map[key] = data[0]
-			this.set()
+			that.Map[key] = data[0]
+			that.set()
 		}
 		return &Obj{Data: nil}
 	}
 
-	return &Obj{Data: this.Map.Get(key)}
+	return &Obj{Data: that.Map.Get(key)}
 
 }
 
-func (this *SessionIns) get() {
+func (that *SessionIns) get() {
 
-	if this.ShortCache != nil {
-		this.Map = this.ShortCache.Cache(HEAD_SESSION_ADD + this.SessionId).ToMap()
-		if this.Map != nil {
-			return
-		}
+	that.Map = that.HoTimeCache.Session(HEAD_SESSION_ADD + that.SessionId).ToMap()
+	if that.Map != nil {
+		return
 	}
 
-	if this.LongCache != nil {
-		this.Map = this.LongCache.Cache(HEAD_SESSION_ADD + this.SessionId).ToMap()
-		if this.Map != nil {
-			if this.ShortCache != nil {
-				this.ShortCache.Cache(HEAD_SESSION_ADD+this.SessionId, this.Map)
-			}
-			return
-		}
-	}
-	this.Map = Map{}
-	this.ShortCache.Cache(HEAD_SESSION_ADD+this.SessionId, this.Map)
+	that.Map = Map{}
+	that.HoTimeCache.Session(HEAD_SESSION_ADD+that.SessionId, that.Map)
 
 	return
 }
 
-func (this *SessionIns) Init(short CacheIns, long CacheIns) {
-	this.ShortCache = short
-	this.LongCache = long
+func (that *SessionIns) Init(cache *HoTimeCache) {
+	that.HoTimeCache = cache
 }

slice.go

@@ -1,87 +0,0 @@
-package hotime
-
-import (
-	"errors"
-)
-
-type Slice []interface{}
-
-//获取string
-func (this Slice) GetString(key int, err ...*Error) string {
-	if len(err) != 0 {
-		err[0].SetError(nil)
-	}
-	return ObjToStr((this)[key])
-}
-
-//获取Int
-func (this Slice) GetInt(key int, err ...*Error) int {
-	v := ObjToInt((this)[key], err...)
-	return v
-}
-
-//获取Int
-func (this Slice) GetInt64(key int, err ...*Error) int64 {
-	v := ObjToInt64((this)[key], err...)
-
-	return v
-}
-
-//获取向上取整Int64
-func (this Slice) GetCeilInt64(key int, err ...*Error) int64 {
-	v := ObjToCeilInt64((this)[key], err...)
-	return v
-
-}
-
-//获取向上取整Int
-func (this Slice) GetCeilInt(key int, err ...*Error) int {
-	v := ObjToCeilInt((this)[key], err...)
-	return v
-
-}
-
-//获取向上取整float64
-func (this Slice) GetCeilFloat64(key int, err ...*Error) float64 {
-	v := ObjToCeilFloat64((this)[key], err...)
-	return v
-
-}
-
-//获取Float64
-func (this Slice) GetFloat64(key int, err ...*Error) float64 {
-	v := ObjToFloat64((this)[key], err...)
-
-	return v
-}
-
-func (this Slice) GetSlice(key int, err ...*Error) Slice {
-	v := ObjToSlice((this)[key], err...)
-	return v
-}
-
-func (this Slice) GetMap(key int, err ...*Error) Map {
-	//var v Map
-	v := ObjToMap((this)[key], err...)
-	return v
-}
-
-func (this Slice) Get(key int, err ...*Error) interface{} {
-
-	if key < len(this) {
-		return this[key]
-	}
-	e := errors.New("没有存储key及对应的数据")
-	if len(err) != 0 {
-		err[0].SetError(e)
-	}
-	return nil
-}
-
-func (this Slice) Put(key int, value interface{}) {
-	this[key] = value
-}
-
-func (this Slice) ToJsonString() string {
-	return ObjToStr(this)
-}

tools/db/auto.go

@@ -1,18 +0,0 @@
-package db
-
-import (
-	"code.hoteas.com/golang/hotime"
-	"code.hoteas.com/golang/hotime/tools/mysql"
-	"code.hoteas.com/golang/hotime/tools/sqlite"
-	"strings"
-)
-
-func SetDB(appIns *hotime.Application) {
-	if appIns.Config.GetString("dbType") == "sqlite" || strings.Index(appIns.Config.GetString("dbName"), ".db") == len(appIns.Config.GetString("dbName"))-3 {
-		appIns.Config["dbType"] = "sqlite"
-		sqlite.SetDB(appIns)
-	} else {
-		appIns.Config["dbType"] = "mysql"
-		mysql.SetDB(appIns)
-	}
-}

tools/mysql/mysql.go

@@ -1,19 +0,0 @@
-package mysql
-
-import (
-	"code.hoteas.com/golang/hotime"
-	"database/sql"
-	_ "github.com/go-sql-driver/mysql"
-)
-
-func SetDB(appIns *hotime.Application) {
-	appIns.SetConnectDB(func(err ...*hotime.Error) *sql.DB {
-		query := appIns.Config.GetString("dbUser") + ":" + appIns.Config.GetString("dbPwd") +
-			"@tcp(" + appIns.Config.GetString("dbHost") + ":" + appIns.Config.GetString("dbPort") + ")/" + appIns.Config.GetString("dbName") + "?charset=utf8"
-		DB, e := sql.Open("mysql", query)
-		if e != nil && len(err) != 0 {
-			err[0].SetError(e)
-		}
-		return DB
-	})
-}

tools/sqlite/sqlite.go

@@ -1,17 +0,0 @@
-package sqlite
-
-import (
-	"code.hoteas.com/golang/hotime"
-	"database/sql"
-	_ "github.com/mattn/go-sqlite3"
-)
-
-func SetDB(appIns *hotime.Application) {
-	appIns.SetConnectDB(func(err ...*hotime.Error) *sql.DB {
-		db, e := sql.Open("sqlite3", appIns.Config.GetString("dbName"))
-		if e != nil && len(err) != 0 {
-			err[0].SetError(e)
-		}
-		return db
-	})
-}

type.go

@@ -1,21 +1,8 @@
 package hotime
 
-//控制器
+// Ctr 控制器
 type Ctr map[string]Method
 type Proj map[string]Ctr
 type Router map[string]Proj
 type MethodRouter map[string]Method //直接字符串关联函数
 type Method func(this *Context)
-
-type CacheIns interface {
-	//set(key string, value interface{}, time int64)
-	//get(key string) interface{}
-	//delete(key string)
-	Cache(key string, data ...interface{}) *Obj
-}
-
-//单条缓存数据
-type cacheData struct {
-	time int64
-	data interface{}
-}

var.go

@@ -1,21 +1,38 @@
 package hotime
 
+import (
+	. "./common"
+)
+
 var IsRun = false                   //当前状态
 var App = map[string]*Application{} //整个项目
 
 //var Db = HoTimeDB{}                         //数据库实例
 
 var Config = Map{
-	"debug":          1, //debug 0关闭1开启
-	"logLevel":       LOG_FMT,
-	"dbHost":         "127.0.0.1",
-	"dbName":         "test",
-	"dbUser":         "root",
-	"dbPwd":          "root",
-	"dbPort":         "3306",
-	"dbCached":       0, //0不开启缓存
-	"cacheShortTime": 60 * 60 * 2,
-	"cacheLongTime":  60 * 60 * 24 * 30,
+	"mode": 3, //模式 0生产模式，1，测试模式，2，开发模式,3，内嵌代码模式
+	"codeConfig": Map{
+		"admin": "config/app.json",
+	},
+	"codeConfig1": Map{
+		"admin": Map{ //默认无，必须，接口类别名称
+			"package": "admin",            //默认admin，非必须，有则生成代码到此目录，无则采用缺省模式不生成代码只生成接口
+			"config":  "config/app.json",  //默认config/app.json，必须，接口描述配置文件
+			"rule":    "config/rule.json", //默认config/rule.json，非必须，有则按改规则生成接口，无则按系统内嵌方式生成
+		},
+	},
+	"db": Map{
+		"sqlite": Map{
+			"path": "config/data.db",
+		},
+	},
+	"cache": Map{
+		"memory": Map{
+			"timeout": 60 * 60 * 2,
+			"db":      true,
+			"session": true,
+		},
+	},
 	"error": Map{
 		"1": "内部系统异常",
 		"2": "访问权限异常",
@@ -23,32 +40,69 @@ var Config = Map{
 		"4": "数据处理异常",
 		"5": "数据结果异常",
 	},
-	"tpt":              "tpt",
-	"defFile":          []string{"index.html", "index.htm"},
-	"modeRouterStrict": false, //路由严格模式/a/b/c
-	"port":             "80",
-	"sessionName":      "HOTIME",
-	"tlsPort":          "0",
-	"tlsKey":           "",
-	"tlsCert":          "",
+	"tpt":         "tpt",
+	"defFile":     []string{"index.html", "index.htm"},
+	"port":        "80",
+	"sessionName": "HOTIME",
 }
 
 var ConfigNote = Map{
-	"logLevel":       "日志等级，0关闭，1打印",
-	"logFile":        "如果需要存储日志文件时使用，保存格式为:a/b/c/20060102150405.txt,将生成：a/b/c/年月日时分秒.txt，按需设置",
-	"debug":          "是否开启debug模式，0关闭，其他开启，debug模式下日志展示更全", //debug 0关闭1开启
-	"dbHost":         "数据库ip地址默认127.0.0.1",
-	"dbName":         "数据库名称，sqlite为文件路径比如a/x.db",
-	"dbUser":         "数据库用户名",
-	"dbPwd":          "数据库密码",
-	"dbPort":         "数据库端口",
-	"dbType":         "如果需要使用自动数据库配置，请设置此项，手动配置数据库不需要，目前支持mysql，sqlite",
-	"dbCached":       "是否开启数据库缓存0为关闭，其他开启", //0不开启缓存
-	"redisHost":      "如果需要使用redis服务时配置，默认服务ip：127.0.0.1",
-	"redisPort":      "如果需要使用redis服务时配置，默认服务端口：6379",
-	"redisPwd":       "如果需要使用redis服务时配置，默认服务密码：123456",
-	"cacheShortTime": "两级缓存，短缓存存储时间60 * 60 * 2，一般为内存缓存",
-	"cacheLongTime":  "两级缓存，长缓存存储时间60 * 60 * 24 * 30，一般为数据库或者redis缓存",
+	"logLevel":          "默认0，必须，0关闭，1打印，日志等级",
+	"logFile":           "无默认，非必须，如果需要存储日志文件时使用，保存格式为:a/b/c/20060102150405.txt,将生成：a/b/c/年月日时分秒.txt，按需设置",
+	"webConnectLogShow": "默认true，非必须，访问日志如果需要web访问链接、访问ip、访问时间打印，false为关闭true开启此功能",
+	"webConnectLogFile": "无默认，非必须，webConnectLogShow开启之后才能使用，如果需要存储日志文件时使用，保存格式为:a/b/c/20060102150405.txt,将生成：a/b/c/年月日时分秒.txt，按需设置",
+	"mode":              "默认0,非必须，0生产模式，1，测试模式，2开发模式，3内嵌代码模式，在开发模式下会显示更多的数据用于开发测试，并能够辅助研发，自动生成配置文件、代码等功能,web无缓存，数据库不启用缓存", //debug 0关闭1开启
+	"codeConfig": Map{
+		"注释": "配置即启用，非必须，默认无",
+		//"package":"默认admin，必须，mode模式为2时会自动生成包文件夹和代码文件",
+		//"path":""
+
+		"packageName": "默认无，必须，包名称以及应用名，生成代码的配置文件地址，比如config/app.json，数据库有更新时自动更新配置文件以及对应的生成文件",
+	},
+	"db": Map{
+		"注释": "配置即启用，非必须，默认使用sqlite数据库",
+		"mysql": Map{
+			"注释":       "除prefix及主从数据库slave项，其他全部必须",
+			"host":     "默认127.0.0.1，必须，数据库ip地址",
+			"name":     "默认test，必须，数据库名称",
+			"user":     "默认root，必须，数据库用户名",
+			"password": "默认root，必须，数据库密码",
+			"port":     "默认3306，必须，数据库端口",
+			"prefix":   "默认空，非必须，数据表前缀",
+			"slave": Map{
+				"注释":       "从数据库配置，mysql里配置slave项即启用主从读写，减少数据库压力",
+				"host":     "默认127.0.0.1，必须，数据库ip地址",
+				"name":     "默认test，必须，数据库名称",
+				"user":     "默认root，必须，数据库用户名",
+				"password": "默认root，必须，数据库密码",
+				"port":     "默认3306，必须，数据库端口",
+			},
+		},
+		"sqlite": Map{
+			"path": "默认config/data.db，必须，数据库位置",
+		},
+	},
+	"cache": Map{
+		"注释": "可配置memory，db，redis，默认启用memory，默认优先级为memory>redis>db,memory与数据库缓存设置项一致，缓存数据填充会自动反方向反哺，加入memory缓存过期将自动从redis更新，但memory永远不会更新redis，如果是集群建议不要开启memory，配置即启用",
+		"memory": Map{
+			"timeout": "默认60 * 60 * 2，非必须，过期时间，超时自动删除",
+			"db":      "默认true，非必须，缓存数据库，启用后能减少数据库的读写压力",
+			"session": "默认true，非必须，缓存web session，同时缓存session保持的用户缓存",
+		},
+		"db": Map{
+			"timeout": "默认60 * 60 * 24 * 30，非必须，过期时间，超时自动删除",
+			"db":      "默认false，非必须，缓存数据库，启用后能减少数据库的读写压力",
+			"session": "默认true，非必须，缓存web session，同时缓存session保持的用户缓存",
+		},
+		"redis": Map{
+			"host":     "默认服务ip：127.0.0.1，必须，如果需要使用redis服务时配置，",
+			"port":     "默认服务端口：6379，必须，如果需要使用redis服务时配置，",
+			"password": "默认密码空，必须，如果需要使用redis服务时配置，默认密码空",
+			"timeout":  "默认60 * 60 * 24 * 15，非必须，过期时间，超时自动删除",
+			"db":       "默认true，非必须，缓存数据库，启用后能减少数据库的读写压力",
+			"session":  "默认true，非必须，缓存web session，同时缓存session保持的用户缓存",
+		},
+	},
 	"error": Map{
 		"1":  "内部系统异常，在环境配置，文件访问权限等基础运行环境条件不足造成严重错误时使用",
 		"2":  "访问权限异常，没有登录或者登录异常等时候使用",
@@ -57,14 +111,13 @@ var ConfigNote = Map{
 		"5":  "数据结果异常，一般用于无法给出response要求的格式要求下使用，比如response需要的是string格式但你只能提供int数据时",
 		"注释": "web服务内置错误提示，自定义异常建议10开始",
 	},
-	"tpt":              "静态文件目录，默认为程序目录下tpt目录",
-	"defFile":          "默认访问文件，默认访问index.html或者index.htm文件",
-	"crossDomain":      "如果需要跨域设置，空字符串为不开启，*为开启所有网站允许跨域，http://www.baidu.com为指定域允许跨域", //是否开启跨域
-	"modeRouterStrict": "路由严格模式false,为大小写忽略必须匹配，true必须大小写匹配",                          //路由严格模式/a/b/c
-	"connectLogShow":   "如果需要web访问链接、访问ip、访问时间打印，0为关闭其他数字开启此功能",
-	"sessionName":      "设置session的cookie名默认HOTIME",
-	"port":             "web服务开启Http端口，0为不启用http服务,默认80",
-	"tlsPort":          "web服务https端口，0为不启用https服务",
-	"tlsKey":           "https密钥",
-	"tlsCert":          "https证书",
+	"tpt":              "默认tpt，必须，web静态文件目录，默认为程序目录下tpt目录",
+	"defFile":          "默认访问index.html或者index.htm文件，必须，默认访问文件类型",
+	"crossDomain":      "默认空 非必须，空字符串为不开启，如果需要跨域设置，auto为智能开启所有网站允许跨域，http://www.baidu.com为指定域允许跨域", //是否开启跨域
+	"modeRouterStrict": "默认false,必须，路由严格模式false,为大小写忽略必须匹配，true必须大小写匹配",                            //路由严格模式/a/b/c
+	"sessionName":      "默认HOTIME，必须，设置session的cookie名",
+	"port":             "默认80，必须，web服务开启Http端口，0为不启用http服务,默认80",
+	"tlsPort":          "默认空，非必须，web服务https端口，0为不启用https服务",
+	"tlsKey":           "默认空，非必须，https密钥",
+	"tlsCert":          "默认空，非必须，https证书",
 }

vendor/code.hoteas.com/golang/hotime/.gitignore

@@ -1 +0,0 @@
-/.idea/*

vendor/code.hoteas.com/golang/hotime/application.go

@@ -1,455 +0,0 @@
-package hotime
-
-import (
-	"bytes"
-	"database/sql"
-	"encoding/json"
-	"io/ioutil"
-	"net/http"
-	"net/url"
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-)
-
-type Application struct {
-	MethodRouter
-	Router
-	contextBase
-	Port            string                     //端口号
-	TLSPort         string                     //ssl访问端口号
-	connectListener []func(this *Context) bool //所有的访问监听,true按原计划继续使用，false表示有监听器处理
-	connectDbFunc   func(err ...*Error) *sql.DB
-	configPath      string
-	Config          Map
-	Db              HoTimeDB
-	Server          *http.Server
-	CacheIns
-	sessionLong  CacheIns
-	sessionShort CacheIns
-	http.Handler
-}
-
-func (this *Application) ServeHTTP(w http.ResponseWriter, req *http.Request) {
-	this.handler(w, req)
-}
-
-//启动实例
-func (this *Application) Run(router Router) {
-	//如果没有设置配置自动生成配置
-	if this.configPath == "" || len(this.Config) == 0 {
-		this.SetConfig()
-	}
-
-	//防止手动设置缓存误伤
-	if this.CacheIns == nil {
-		this.SetCache(CacheIns(&CacheMemory{}))
-	}
-
-	//防止手动设置session误伤
-	if this.sessionShort == nil && this.sessionLong == nil {
-		if this.connectDbFunc == nil {
-			this.SetSession(CacheIns(&CacheMemory{}), nil)
-		} else {
-			this.SetSession(CacheIns(&CacheMemory{}), CacheIns(&CacheDb{Db: &this.Db, Time: this.Config.GetInt64("cacheLongTime")}))
-		}
-
-	}
-
-	this.Router = router
-	//重新设置MethodRouter//直达路由
-	this.MethodRouter = MethodRouter{}
-	modeRouterStrict := true
-	if this.Config.Get("modeRouterStrict").(bool) == false {
-		modeRouterStrict = false
-	}
-	if router != nil {
-		for pk, pv := range router {
-			if !modeRouterStrict {
-				pk = strings.ToLower(pk)
-			}
-			if pv != nil {
-				for ck, cv := range pv {
-					if !modeRouterStrict {
-						ck = strings.ToLower(ck)
-					}
-					if cv != nil {
-						for mk, mv := range cv {
-							if !modeRouterStrict {
-								mk = strings.ToLower(mk)
-							}
-							this.MethodRouter["/"+pk+"/"+ck+"/"+mk] = mv
-						}
-					}
-				}
-			}
-		}
-	}
-
-	//this.Port = port
-	this.Port = this.Config.GetString("port")
-	this.TLSPort = this.Config.GetString("tlsPort")
-
-	if this.connectDbFunc != nil && (this.Db.DB == nil || this.Db.DB.Ping() != nil) {
-		this.Db.SetConnect(this.connectDbFunc)
-	}
-
-	if this.CacheIns == nil {
-		this.CacheIns = CacheIns(&CacheMemory{Map: Map{}, Time: this.Config.GetInt64("cacheShortTime")})
-	}
-
-	//异常处理
-	defer func() {
-		if err := recover(); err != nil {
-			//this.SetError(errors.New(fmt.Sprint(err)), LOG_FMT)
-			logFmt(err, 2, LOG_ERROR)
-
-			this.Run(router)
-		}
-	}()
-
-	this.Server = &http.Server{}
-	if !IsRun {
-		IsRun = true
-	}
-
-	ch := make(chan int)
-	if ObjToCeilInt(this.Port) != 0 {
-		go func() {
-
-			App[this.Port] = this
-			this.Server.Handler = this
-			//启动服务
-			this.Server.Addr = ":" + this.Port
-			err := this.Server.ListenAndServe()
-			logFmt(err, 2)
-			ch <- 1
-
-		}()
-	} else if ObjToCeilInt(this.TLSPort) != 0 {
-		go func() {
-
-			App[this.TLSPort] = this
-			this.Server.Handler = this
-			//启动服务
-			this.Server.Addr = ":" + this.TLSPort
-			err := this.Server.ListenAndServeTLS(this.Config.GetString("tlsCert"), this.Config.GetString("tlsKey"))
-			logFmt(err, 2)
-			ch <- 2
-
-		}()
-	} else {
-		logFmt("没有端口启用", 2, LOG_INFO)
-		return
-
-	}
-
-	value := <-ch
-
-	logFmt("启动服务失败 : "+ObjToStr(value), 2, LOG_ERROR)
-}
-
-//启动实例
-func (this *Application) SetConnectDB(connect func(err ...*Error) *sql.DB) {
-
-	//this.Db.DBCached=false
-	//if this.Config.GetCeilInt("dbCached")!=0{
-	//	this.Db.DBCached=true
-	//}
-
-	this.connectDbFunc = connect
-	this.Db.SetConnect(this.connectDbFunc)
-
-	this.Db.DBCached = false
-	if this.Config.GetCeilInt("dbCached") != 0 {
-		this.Db.DBCached = true
-	}
-
-	this.Db.Type = this.Config.GetString("dbType")
-
-}
-
-//设置配置文件路径全路径或者相对路径
-func (this *Application) SetSession(short CacheIns, Long CacheIns) {
-	this.sessionLong = Long
-	this.sessionShort = short
-
-}
-
-//默认配置缓存和session实现
-func (this *Application) SetDefault(connect func(err ...*Error) *sql.DB) {
-	this.SetConfig()
-
-	if connect != nil {
-		this.connectDbFunc = connect
-		this.Db.SetConnect(this.connectDbFunc)
-	}
-
-}
-
-//设置配置文件路径全路径或者相对路径
-func (this *Application) SetCache(cache CacheIns) {
-
-	this.CacheIns = cache
-
-}
-
-//设置配置文件路径全路径或者相对路径
-func (this *Application) SetConfig(configPath ...string) {
-	if len(configPath) != 0 {
-		this.configPath = configPath[0]
-	}
-
-	if this.configPath == "" {
-		this.configPath = "config/config.json"
-	}
-	//加载配置文件
-	btes, err := ioutil.ReadFile(this.configPath)
-	this.Config = DeepCopyMap(Config).(Map)
-	if err == nil {
-
-		cmap := Map{}
-		//文件是否损坏
-		cmap.JsonToMap(string(btes), &this.Error)
-
-		for k, v := range cmap {
-			this.Config[k] = v //程序配置
-			Config[k] = v      //系统配置
-		}
-	} else {
-		logFmt("配置文件不存在，或者配置出错，使用缺省默认配置", 2)
-
-	}
-
-	//文件如果损坏则不写入配置防止配置文件数据丢失
-	if this.Error.GetError() == nil {
-		var configByte bytes.Buffer
-
-		err = json.Indent(&configByte, []byte(this.Config.ToJsonString()), "", "\t")
-		//判断配置文件是否序列有变化有则修改配置，五则不变
-		//fmt.Println(len(btes))
-		if len(btes) != 0 && configByte.String() == string(btes) {
-			return
-		}
-		//写入配置说明
-		var configNoteByte bytes.Buffer
-		json.Indent(&configNoteByte, []byte(ConfigNote.ToJsonString()), "", "\t")
-
-		os.MkdirAll(filepath.Dir(this.configPath), os.ModeDir)
-		err = ioutil.WriteFile(this.configPath, configByte.Bytes(), os.ModeAppend)
-		if err != nil {
-			this.Error.SetError(err)
-		}
-		ioutil.WriteFile(filepath.Dir(this.configPath)+"/confignote.json", configNoteByte.Bytes(), os.ModeAppend)
-
-	}
-
-}
-
-//连接判断,返回true继续传输至控制层，false则停止传输
-func (this *Application) SetConnectListener(lis func(this *Context) bool) {
-	this.connectListener = append(this.connectListener, lis)
-}
-
-//网络错误
-//func (this *Application) session(w http.ResponseWriter, req *http.Request) {
-//
-//}
-
-//序列化链接
-func (this *Application) urlSer(url string) (string, []string) {
-	q := strings.Index(url, "?")
-	if q == -1 {
-		q = len(url)
-	}
-	o := Substr(url, 0, q)
-
-	r := strings.SplitN(o, "/", -1)
-
-	var s = make([]string, 0)
-
-	for i := 0; i < len(r); i++ {
-		if !strings.EqualFold("", r[i]) {
-			s = append(s, r[i])
-		}
-	}
-	return o, s
-}
-
-//访问
-
-func (this *Application) handler(w http.ResponseWriter, req *http.Request) {
-
-	_, s := this.urlSer(req.RequestURI)
-	//获取cookie
-	// 如果cookie存在直接将sessionId赋值为cookie.Value
-	// 如果cookie不存在就查找传入的参数中是否有token
-	// 如果token不存在就生成随机的sessionId
-	// 如果token存在就判断token是否在Session中有保存
-	// 如果有取出token并复制给cookie
-	// 没有保存就生成随机的session
-	cookie, err := req.Cookie(this.Config.GetString("sessionName"))
-	sessionId := Md5(strconv.Itoa(Rand(10)))
-	token := req.FormValue("token")
-	//isFirst:=false
-	if err != nil || (len(token) == 32 && cookie.Value != token) {
-		if len(token) == 32 {
-			sessionId = token
-		}
-		//else{
-		//	isFirst=true;
-		//}
-		http.SetCookie(w, &http.Cookie{Name: this.Config.GetString("sessionName"), Value: sessionId, Path: "/"})
-	} else {
-		sessionId = cookie.Value
-	}
-
-	unescapeUrl, err := url.QueryUnescape(req.RequestURI)
-	if err != nil {
-		unescapeUrl = req.RequestURI
-	}
-	//访问实例
-	context := Context{SessionIns: SessionIns{SessionId: sessionId,
-		LongCache:  this.sessionLong,
-		ShortCache: this.sessionShort,
-	},
-		CacheIns: this.CacheIns,
-		Resp:     w, Req: req, Application: this, RouterString: s, Config: this.Config, Db: &this.Db, HandlerStr: unescapeUrl}
-	//header默认设置
-	header := w.Header()
-	header.Set("Content-Type", "text/html; charset=utf-8")
-
-	//url去掉参数并序列化
-	context.HandlerStr, context.RouterString = this.urlSer(context.HandlerStr)
-
-	//跨域设置
-	this.crossDomain(&context)
-	//是否展示日志
-	if this.Config.GetInt("connectLogShow") != 0 {
-		logFmt(Substr(context.Req.RemoteAddr, 0, strings.Index(context.Req.RemoteAddr, ":"))+" "+context.HandlerStr, 0, LOG_INFO)
-	}
-
-	//访问拦截true继续false暂停
-	connectListenerLen := len(this.connectListener)
-	if connectListenerLen != 0 {
-		for i := 0; i < connectListenerLen; i++ {
-
-			if !this.connectListener[i](&context) {
-
-				context.View()
-				return
-			}
-		}
-	}
-
-	//接口服务
-	//if len(s) == 3 {
-	//	//如果满足规则则路由到对应控制器去
-	//	if this.Router[s[0]] != nil && this.Router[s[0]][s[1]] != nil && this.Router[s[0]][s[1]][s[2]] != nil {
-	//		//控制层
-	//		this.Router[s[0]][s[1]][s[2]](&context)
-	//		//header.Set("Content-Type", "text/html; charset=utf-8")
-	//		context.View()
-	//		return
-	//	}
-	//
-	//}
-	//验证接口严格模式
-	modeRouterStrict := this.Config.Get("modeRouterStrict").(bool)
-	tempHandlerStr := context.HandlerStr
-	if !modeRouterStrict {
-		tempHandlerStr = strings.ToLower(tempHandlerStr)
-	}
-
-	//执行接口
-	if this.MethodRouter[tempHandlerStr] != nil {
-		this.MethodRouter[tempHandlerStr](&context)
-		context.View()
-		return
-	}
-
-	//url赋值
-	path := this.Config.GetString("tpt") + tempHandlerStr
-
-	//判断是否为默认
-	if path[len(path)-1] == '/' {
-		defFile := this.Config.GetSlice("defFile")
-
-		for i := 0; i < len(defFile); i++ {
-			temp := path + defFile.GetString(i)
-			_, err := os.Stat(temp)
-
-			if err == nil {
-				path = temp
-				break
-			}
-		}
-		if path[len(path)-1] == '/' {
-			w.WriteHeader(404)
-			return
-		}
-	}
-
-	if strings.Contains(path, "/.") {
-		w.WriteHeader(404)
-		return
-	}
-
-	//设置header
-	delete(header, "Content-Type")
-	if this.Config.GetInt("debug") != 1 {
-		header.Set("Cache-Control", "public")
-	}
-
-	if strings.Index(path, ".m3u8") != -1 {
-		header.Add("Content-Type", "audio/mpegurl")
-	}
-
-	//w.Write(data)
-	http.ServeFile(w, req, path)
-
-}
-
-func (this *Application) crossDomain(context *Context) {
-	//没有跨域设置
-	if context.Config.GetString("crossDomain") == "" {
-		return
-	}
-
-	header := context.Resp.Header()
-	header.Set("Access-Control-Allow-Origin", "*")
-	header.Set("Access-Control-Allow-Methods", "*")
-	header.Set("Access-Control-Allow-Credentials", "true")
-	header.Set("Access-Control-Expose-Headers", "*")
-	header.Set("Access-Control-Allow-Headers", "X-Requested-With,Content-Type,Access-Token")
-
-	if context.Config.GetString("crossDomain") != "*" {
-		header.Set("Access-Control-Allow-Origin", this.Config.GetString("crossDomain"))
-		return
-	}
-
-	origin := context.Req.Header.Get("Origin")
-	if origin != "" {
-		header.Set("Access-Control-Allow-Origin", origin)
-		return
-	}
-
-	refer := context.Req.Header.Get("Referer")
-	if refer != "" {
-		tempInt := 0
-		lastInt := strings.IndexFunc(refer, func(r rune) bool {
-			if r == '/' && tempInt > 8 {
-				return true
-			}
-			tempInt++
-			return false
-		})
-
-		if lastInt < 0 {
-			lastInt = len(refer)
-		}
-		refer = Substr(refer, 0, lastInt)
-		header.Set("Access-Control-Allow-Origin", refer)
-	}
-}

vendor/code.hoteas.com/golang/hotime/cache_db.go

@@ -1,146 +0,0 @@
-package hotime
-
-import (
-	"encoding/json"
-	"strings"
-	"time"
-)
-
-type CacheDb struct {
-	Time int64
-	Db   *HoTimeDB
-	contextBase
-	isInit bool
-}
-
-func (this *CacheDb) initDbTable() {
-	if this.isInit {
-		return
-	}
-	if this.Db.Type == "mysql" {
-
-		dbNames := this.Db.Query("SELECT DATABASE()")
-
-		if len(dbNames) == 0 {
-			return
-		}
-		dbName := dbNames[0].GetString("DATABASE()")
-		res := this.Db.Query("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA='" + dbName + "' AND TABLE_NAME='cached'")
-		if len(res) != 0 {
-			this.isInit = true
-			return
-		}
-
-		_, e := this.Db.Exec("CREATE TABLE `cached` ( `id` int(11) unsigned NOT NULL AUTO_INCREMENT, `ckey` varchar(60) DEFAULT NULL, `cvalue` varchar(2000) DEFAULT NULL, `time` bigint(20) DEFAULT NULL, `endtime` bigint(20) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=198740 DEFAULT CHARSET=utf8")
-		if e.GetError() == nil {
-			this.isInit = true
-		}
-
-	}
-
-	if this.Db.Type == "sqlite" {
-		res := this.Db.Query(`select * from sqlite_master where type = 'table' and name = 'cached'`)
-
-		if len(res) != 0 {
-			this.isInit = true
-			return
-		}
-		_, e := this.Db.Exec(`CREATE TABLE "cached" (
-			"id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
-				"ckey" TEXT(60),
-				"cvalue" TEXT(2000),
-				"time" integer,
-				"endtime" integer
-			);`)
-		if e.GetError() == nil {
-			this.isInit = true
-		}
-
-	}
-
-}
-
-//获取Cache键只能为string类型
-func (this *CacheDb) get(key string) interface{} {
-
-	cached := this.Db.Get("cached", "*", Map{"ckey": key})
-
-	if cached == nil {
-		return nil
-	}
-	//data:=cacheMap[key];
-	if cached.GetInt64("endtime") <= time.Now().Unix() {
-
-		this.Db.Delete("cached", Map{"id": cached.GetString("id")})
-		return nil
-	}
-
-	data := Map{}
-	data.JsonToMap(cached.GetString("cvalue"))
-
-	return data.Get("data")
-}
-
-//key value ,时间为时间戳
-func (this *CacheDb) set(key string, value interface{}, tim int64) {
-
-	bte, _ := json.Marshal(Map{"data": value})
-
-	num := this.Db.Update("cached", Map{"cvalue": string(bte), "time": time.Now().UnixNano(), "endtime": tim}, Map{"ckey": key})
-	if num == int64(0) {
-		this.Db.Insert("cached", Map{"cvalue": string(bte), "time": time.Now().UnixNano(), "endtime": tim, "ckey": key})
-	}
-
-	//随机执行删除命令
-	if Rand(1000) > 950 {
-		this.Db.Delete("cached", Map{"endtime[<]": time.Now().Unix()})
-	}
-}
-
-func (this *CacheDb) delete(key string) {
-
-	del := strings.Index(key, "*")
-	//如果通配删除
-	if del != -1 {
-		key = Substr(key, 0, del)
-		this.Db.Delete("cached", Map{"ckey": key + "%"})
-
-	} else {
-		this.Db.Delete("cached", Map{"ckey": key})
-	}
-}
-
-func (this *CacheDb) Cache(key string, data ...interface{}) *Obj {
-
-	this.initDbTable()
-
-	if len(data) == 0 {
-		return &Obj{Data: this.get(key)}
-	}
-	tim := time.Now().Unix()
-
-	if len(data) == 1 && data[0] == nil {
-		this.delete(key)
-		return &Obj{Data: nil}
-	}
-
-	if len(data) == 1 {
-		if this.Time == 0 {
-			this.Time = Config.GetInt64("cacheLongTime")
-		}
-		tim += this.Time
-	}
-	if len(data) == 2 {
-		this.SetError(nil)
-		tempt := ObjToInt64(data[1], &this.Error)
-
-		if tempt > tim {
-			tim = tempt
-		} else if this.GetError() == nil {
-
-			tim = tim + tempt
-		}
-	}
-	this.set(key, data[0], tim)
-	return &Obj{Data: nil}
-}

vendor/code.hoteas.com/golang/hotime/cache_memory.go

@@ -1,146 +0,0 @@
-package hotime
-
-import (
-	"strings"
-	"sync"
-	"time"
-)
-
-type CacheMemory struct {
-	Time int64
-	Map
-	contextBase
-	mutex *sync.RWMutex
-}
-
-//获取Cache键只能为string类型
-func (this *CacheMemory) get(key string) interface{} {
-	this.Error.SetError(nil)
-	if this.Map == nil {
-		this.Map = Map{}
-	}
-
-	if this.Map[key] == nil {
-		return nil
-	}
-	data := this.Map.Get(key, &this.Error).(cacheData)
-	if this.GetError() != nil {
-		return nil
-	}
-
-	if data.time < time.Now().Unix() {
-		delete(this.Map, key)
-		return nil
-	}
-	return data.data
-}
-
-func (this *CacheMemory) refreshMap() {
-
-	go func() {
-		this.mutex.Lock()
-		defer this.mutex.Unlock()
-		for key, v := range this.Map {
-			data := v.(cacheData)
-			if data.time <= time.Now().Unix() {
-				delete(this.Map, key)
-			}
-		}
-
-	}()
-
-}
-
-//key value ,时间为时间戳
-func (this *CacheMemory) set(key string, value interface{}, time int64) {
-	this.Error.SetError(nil)
-	var data cacheData
-
-	if this.Map == nil {
-		this.Map = Map{}
-	}
-
-	dd := this.Map[key]
-
-	if dd == nil {
-		data = cacheData{}
-	} else {
-		data = dd.(cacheData)
-	}
-
-	data.time = time
-	data.data = value
-
-	this.Map.Put(key, data)
-}
-
-func (this *CacheMemory) delete(key string) {
-	del := strings.Index(key, "*")
-	//如果通配删除
-	if del != -1 {
-		key = Substr(key, 0, del)
-		for k, _ := range this.Map {
-			if strings.Index(k, key) != -1 {
-				delete(this.Map, key)
-			}
-		}
-
-	} else {
-		delete(this.Map, key)
-	}
-
-}
-
-func (this *CacheMemory) Cache(key string, data ...interface{}) *Obj {
-
-	x := RandX(1, 100000)
-	if x > 99950 {
-		this.refreshMap()
-	}
-	if this.mutex == nil {
-		this.mutex = &sync.RWMutex{}
-	}
-
-	reData := &Obj{Data: nil}
-
-	if len(data) == 0 {
-		this.mutex.RLock()
-		reData.Data = this.get(key)
-		this.mutex.RUnlock()
-		return reData
-	}
-	tim := time.Now().Unix()
-
-	if len(data) == 1 && data[0] == nil {
-		this.mutex.Lock()
-		this.delete(key)
-		this.mutex.Unlock()
-		return reData
-	}
-
-	if len(data) == 1 {
-		if this.Time == 0 {
-			this.Time = Config.GetInt64("cacheShortTime")
-		}
-
-		tim = tim + this.Time
-
-	}
-	if len(data) == 2 {
-		this.Error.SetError(nil)
-		tempt := ObjToInt64(data[1], &this.Error)
-
-		if tempt > tim {
-
-			tim = tempt
-		} else if this.GetError() == nil {
-
-			tim = tim + tempt
-		}
-	}
-	this.mutex.Lock()
-	this.set(key, data[0], tim)
-	this.mutex.Unlock()
-	return reData
-
-}

vendor/code.hoteas.com/golang/hotime/const.go

@@ -1,16 +0,0 @@
-package hotime
-
-type LOG_MODE int
-
-const (
-	LOG_NIL = 0
-	LOG_FMT = 1
-	//LOG_FILE  = 2
-
-	LOG_INFO  LOG_MODE = 0
-	LOG_WARN  LOG_MODE = 1
-	LOG_ERROR LOG_MODE = 2
-)
-
-//session储存头
-const HEAD_SESSION_ADD = "session#"

vendor/code.hoteas.com/golang/hotime/context.go

@@ -1,65 +0,0 @@
-package hotime
-
-import (
-	"encoding/json"
-	"errors"
-	"net/http"
-)
-
-type Context struct {
-	contextBase
-	Resp         http.ResponseWriter
-	Req          *http.Request
-	Application  *Application
-	RouterString []string
-	Config       Map
-	Db           *HoTimeDB
-	RespData     Map
-	CacheIns
-	SessionIns
-	HandlerStr string //复写请求url
-}
-
-//唯一标志
-func (this *Context) Mtd(router [3]string) Map {
-	this.Application.Router[router[0]][router[1]][router[2]](this)
-	d := this.RespData
-	this.RespData = nil
-	return d
-}
-
-//打印
-func (this *Context) Display(statu int, data interface{}) {
-
-	resp := Map{"statu": statu}
-	if statu != 0 {
-		temp := Map{}
-
-		tpe := this.Config.GetMap("error").GetString(ObjToStr(statu))
-		if tpe == "" {
-			logFmt(errors.New("找不到对应的错误码"), 2, LOG_WARN)
-		}
-
-		temp["type"] = tpe
-		temp["msg"] = data
-		resp["result"] = temp
-	} else {
-		resp["result"] = data
-	}
-
-	this.RespData = resp
-
-	//this.Data=d;
-}
-
-func (this *Context) View() {
-	if this.RespData == nil {
-		return
-	}
-	d, err := json.Marshal(this.RespData)
-	if err != nil {
-		return
-	}
-	this.RespData = nil
-	this.Resp.Write(d)
-}

vendor/code.hoteas.com/golang/hotime/context_base.go

@@ -1,17 +0,0 @@
-package hotime
-
-import "time"
-
-type contextBase struct {
-	Error
-	tag int64
-}
-
-//唯一标志
-func (this *contextBase) GetTag() int64 {
-
-	if this.tag == int64(0) {
-		this.tag = time.Now().UnixNano()
-	}
-	return this.tag
-}

vendor/code.hoteas.com/golang/hotime/error.go

@@ -1,25 +0,0 @@
-package hotime
-
-//框架层处理错误
-type Error struct {
-	error
-	err error
-}
-
-func (this *Error) GetError() error {
-
-	return this.error
-
-}
-
-func (this *Error) SetError(err error, loglevel ...int) {
-
-	this.error = nil
-	if err == nil {
-		this.error = err
-		this.err = err
-		return
-	}
-	this.error = err
-	return
-}

vendor/code.hoteas.com/golang/hotime/func.go

@@ -1,382 +0,0 @@
-package hotime
-
-import (
-	"crypto/md5"
-	"encoding/hex"
-	"fmt"
-	"math"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"time"
-)
-
-//安全锁
-//func SafeMutex(tag int, f func() interface{}) interface{} {
-//
-//	mutexer.Lock()
-//	if mutex[tag] == nil {
-//
-//		mutex[tag] = &sync.RWMutex{}
-//
-//	}
-//	mutexer.Unlock()
-//
-//	mutex[tag].Lock()
-//	res := f()
-//	mutex[tag].Unlock()
-//	return res
-//}
-
-func LogError(logMsg interface{}) {
-
-	logFmt(fmt.Sprintln(logMsg), 2, LOG_ERROR)
-}
-func LogWarn(logMsg interface{}) {
-
-	logFmt(fmt.Sprintln(logMsg), 2, LOG_WARN)
-}
-func LogInfo(logMsg ...interface{}) {
-
-	logFmt(fmt.Sprintln(logMsg), 2, LOG_INFO)
-}
-
-//func LogFmt(logMsg interface{}, loglevel ...LOG_MODE) {
-//
-//	logFmt(logMsg, 2, loglevel...)
-//}
-
-//日志打印以及存储到文件
-func logFmt(logMsg interface{}, printLevel int, loglevel ...LOG_MODE) {
-
-	if Config.GetInt("logLevel") == int(LOG_NIL) {
-		return
-	}
-
-	lev := LOG_INFO
-	if len(loglevel) != 0 {
-		lev = loglevel[0]
-	}
-	gofile := ""
-
-	if Config.GetInt("debug") != 0 && printLevel != 0 {
-		_, file, line, ok := runtime.Caller(printLevel)
-		if ok {
-			gofile = " " + file + ":" + ObjToStr(line)
-		}
-	}
-
-	logStr := ""
-
-	if lev == LOG_INFO {
-		logStr = "info:"
-	}
-	if printLevel == 0 {
-		logStr = "connect:"
-	}
-
-	if lev == LOG_WARN {
-		logStr = "warn:"
-	}
-
-	if lev == LOG_ERROR {
-		logStr = "error:"
-	}
-
-	logStr = fmt.Sprintln(time.Now().Format("2006/01/02 15:04:05"), logStr, logMsg, gofile)
-	//打印日志
-	fmt.Print(logStr)
-	//不需要存储到文件
-	if Config.GetString("logFile") == "" {
-		return
-	}
-	//存储到文件
-	logFilePath := time.Now().Format(Config.GetString("logFile"))
-
-	os.MkdirAll(filepath.Dir(logFilePath), os.ModeAppend)
-	//os.Create(logFilePath)
-	f, err := os.OpenFile(logFilePath, os.O_APPEND|os.O_CREATE, 0644)
-	if err != nil {
-		return
-	}
-	f.Write([]byte(logStr))
-	f.Close()
-
-}
-
-//字符串首字符大写
-func StrFirstToUpper(str string) string {
-	if len(str) == 0 {
-		return str
-	}
-
-	first := Substr(str, 0, 1)
-	other := Substr(str, 1, len(str)-1)
-
-	return strings.ToUpper(first) + other
-}
-
-//字符串截取
-func Substr(str string, start int, length int) string {
-	rs := []rune(str)
-	rl := len(rs)
-	end := 0
-
-	if start < 0 {
-		start = rl - 1 + start
-	}
-	end = start + length
-
-	if start > end {
-		start, end = end, start
-	}
-
-	if start < 0 {
-		start = 0
-	}
-	if start > rl {
-		start = rl
-	}
-	if end < 0 {
-		end = 0
-	}
-	if end > rl {
-		end = rl
-	}
-
-	return string(rs[start:end])
-}
-
-//获取最后出现字符串的下标
-//return  找不到返回 -1
-func IndexLastStr(str, sep string) int {
-	sepSlice := []rune(sep)
-	strSlice := []rune(str)
-	if len(sepSlice) > len(strSlice) {
-		return -1
-	}
-
-	v := sepSlice[len(sepSlice)-1]
-
-	for i := len(strSlice) - 1; i >= 0; i-- {
-		vs := strSlice[i]
-		if v == vs {
-			j := len(sepSlice) - 2
-			for ; j >= 0; j-- {
-				vj := sepSlice[j]
-				vsj := strSlice[i-(len(sepSlice)-j-1)]
-				if vj != vsj {
-					break
-				}
-			}
-			if j < 0 {
-				return i - len(sepSlice) + 1
-			}
-		}
-
-	}
-	return -1
-}
-
-//md5
-func Md5(req string) string {
-	md5Ctx := md5.New()
-	md5Ctx.Write([]byte(req))
-	cipherStr := md5Ctx.Sum(nil)
-	return hex.EncodeToString(cipherStr)
-}
-
-//随机数
-func Rand(count int) int {
-	res := Random()
-	for i := 0; i < count; i++ {
-		res = res * 10
-	}
-	return ObjToInt(res)
-}
-func Random() float64 {
-	v := float64(0)
-	m := float64(0.1)
-	for i := 0; i < 15; i++ {
-		facter := map[int]int{4: 1, 9: 1, 2: 1, 3: 1, 1: 1, 7: 1, 0: 1, 5: 1, 6: 1, 8: 1}
-		for k, _ := range facter {
-
-			v = v + float64(k)*m
-			break
-		}
-		m = m * 0.1
-	}
-
-	return v
-
-}
-
-//随机数范围
-func RandX(small int, max int) int {
-	res := 0
-	//随机对象
-	if small == max {
-		return small
-	}
-
-	for {
-		res = ObjToInt(Random() * float64(max+1))
-		if res >= small {
-			break
-		}
-	}
-	return res
-}
-
-//
-////路由
-//func Router(ctr CtrInterface) {
-//
-//	str := reflect.ValueOf(ctr).Type().String()
-//	a := strings.IndexByte(str, '.')
-//
-//	c := len(str) - len("Ctr") - 1
-//
-//	app := Substr(str, 0, a)    //属于哪个app
-//	ct := Substr(str, a+1, c-a) //属于哪个控制器
-//	var x = map[string]CtrInterface{}
-//	if _, ok := Proj[app]; ok {
-//		//存在APP
-//		x = Proj[app]
-//	} else {
-//		x = map[string]CtrInterface{}
-//	}
-//	x[ct] = ctr //将控制器存入APP
-//	//	fmt.Println(c)
-//	Proj[app] = x //将APP存入测试
-//}
-//
-//func RunMethodListener(test func(app []string)) {
-//	RunMethodListenerFunc = test
-//}
-
-//func SetDb(db *sql.DB) {
-//	db.SetMaxOpenConns(2000)
-//	db.SetMaxIdleConns(1000)
-//	db.Ping()
-//	SqlDB = &*db
-//	GetDb()
-//}
-
-//复制返回数组
-func DeepCopyMap(value interface{}) interface{} {
-	if valueMap, ok := value.(Map); ok {
-		newMap := make(Map)
-		for k, v := range valueMap {
-			newMap[k] = DeepCopyMap(v)
-		}
-
-		return newMap
-	} else if valueSlice, ok := value.([]interface{}); ok {
-		newSlice := make([]interface{}, len(valueSlice))
-		for k, v := range valueSlice {
-			newSlice[k] = DeepCopyMap(v)
-		}
-
-		return newSlice
-	} else if valueMap, ok := value.(map[string]interface{}); ok {
-		newMap := make(map[string]interface{})
-		for k, v := range valueMap {
-			newMap[k] = DeepCopyMap(v)
-		}
-
-		return newMap
-
-	} else if valueSlice, ok := value.(Slice); ok {
-		newSlice := make(Slice, len(valueSlice))
-		for k, v := range valueSlice {
-			newSlice[k] = DeepCopyMap(v)
-		}
-
-		return newSlice
-	}
-
-	return value
-}
-
-////获取数据库
-//func GetDb() (HoTimeDB, error) {
-//	Db.DB = &*SqlDB
-//	Db.Cached = true
-//	return Db, nil
-//}
-
-//初始化方法
-//func Init() {
-//
-//	http.HandleFunc("/", PublicCore.myHandler)
-//
-//	InitCache()
-//	http.ListenAndServe(":"+Config["port"].(string), nil)
-//}
-
-////设置Config
-//func SetCfg(tData Map) {
-//	for k, v := range tData {
-//		Config[k] = v
-//	}
-//}
-
-//浮点数四舍五入保留小数
-func Round(f float64, n int) float64 {
-	pow10_n := math.Pow10(n)
-	return math.Trunc((f+0.5/pow10_n)*pow10_n) / pow10_n
-}
-
-//func InitDbCache(tim int64) {
-//	res := Db.Query("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA='" + Config.GetString("dbName") + "' AND TABLE_NAME='cached'")
-//	if len(res) == 0 {
-//		Db.Exec("CREATE TABLE `cached` ( `id` int(11) unsigned NOT NULL AUTO_INCREMENT, `ckey` varchar(60) DEFAULT NULL, `cvalue` varchar(2000) DEFAULT NULL, `time` bigint(20) DEFAULT NULL, `endtime` int(11) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=198740 DEFAULT CHARSET=utf8")
-//	}
-//	cacheConfig := Config.GetMap("cacheConfig").GetObj("db").(CacheConfg)
-//	cacheConfig.Used = true
-//	if tim != 0 {
-//		cacheConfig.Time = tim
-//	}
-//	Config.GetMap("cacheConfig")["db"] = cacheConfig
-//}
-//
-//func Cache(key interface{}, data ...interface{}) interface{} {
-//	cachePRI := Config["cachePRI"].([]string)
-//	var res interface{}
-//	for i := 0; i < len(cachePRI); i++ {
-//		if cachePRI[i] == "ridis" && Config["cacheConfig"].(Map)["ridis"].(CacheConfg).Used {
-//			res = CacheMemIns.Cache(ObjToStr(key), data...)
-//		}
-//		if cachePRI[i] == "db" && Config["cacheConfig"].(Map)["db"].(CacheConfg).Used {
-//			res = CacheDBIns.Cache(ObjToStr(key), data...)
-//		}
-//		if cachePRI[i] == "memory" && Config["cacheConfig"].(Map)["memory"].(CacheConfg).Used {
-//			res = CacheMemIns.Cache(ObjToStr(key), data...)
-//		}
-//		//将缓存送到前面的可缓存仓库去
-//		if res != nil {
-//			for j := 0; j < i; j++ {
-//				if cachePRI[j] == "ridis" && Config["cacheConfig"].(Map)["ridis"].(CacheConfg).Used {
-//					CacheMemIns.Cache(ObjToStr(key), res)
-//				}
-//				if cachePRI[j] == "db" && Config["cacheConfig"].(Map)["db"].(CacheConfg).Used {
-//					CacheDBIns.Cache(ObjToStr(key), res)
-//				}
-//				if cachePRI[j] == "memory" && Config["cacheConfig"].(Map)["memory"].(CacheConfg).Used {
-//					CacheMemIns.Cache(ObjToStr(key), res)
-//				}
-//
-//			}
-//			break
-//		}
-//
-//	}
-//	return res
-//}
-
-//func InitCache() {
-//	CacheMemIns.Init(Config["cacheConfig"].(Map)["memory"].(CacheConfg).Time)
-//	CacheDBIns.Init(Config["cacheConfig"].(Map)["db"].(CacheConfg).Time)
-//}

vendor/code.hoteas.com/golang/hotime/mime.go

@@ -1,543 +0,0 @@
-package hotime
-
-var MimeMaps = map[string]string{
-	".3dm":         "x-world/x-3dmf",
-	".3dmf":        "x-world/x-3dmf",
-	".7z":          "application/x-7z-compressed",
-	".a":           "application/octet-stream",
-	".aab":         "application/x-authorware-bin",
-	".aam":         "application/x-authorware-map",
-	".aas":         "application/x-authorware-seg",
-	".abc":         "text/vndabc",
-	".ace":         "application/x-ace-compressed",
-	".acgi":        "text/html",
-	".m3u8":        "audio/mpegurl",
-	".afl":         "video/animaflex",
-	".ai":          "application/postscript",
-	".aif":         "audio/aiff",
-	".aifc":        "audio/aiff",
-	".aiff":        "audio/aiff",
-	".aim":         "application/x-aim",
-	".aip":         "text/x-audiosoft-intra",
-	".alz":         "application/x-alz-compressed",
-	".ani":         "application/x-navi-animation",
-	".aos":         "application/x-nokia-9000-communicator-add-on-software",
-	".aps":         "application/mime",
-	".apk":         "application/vnd.android.package-archive",
-	".arc":         "application/x-arc-compressed",
-	".arj":         "application/arj",
-	".art":         "image/x-jg",
-	".asf":         "video/x-ms-asf",
-	".asm":         "text/x-asm",
-	".asp":         "text/asp",
-	".asx":         "application/x-mplayer2",
-	".au":          "audio/basic",
-	".avi":         "video/x-msvideo",
-	".avs":         "video/avs-video",
-	".bcpio":       "application/x-bcpio",
-	".bin":         "application/mac-binary",
-	".bmp":         "image/bmp",
-	".boo":         "application/book",
-	".book":        "application/book",
-	".boz":         "application/x-bzip2",
-	".bsh":         "application/x-bsh",
-	".bz2":         "application/x-bzip2",
-	".bz":          "application/x-bzip",
-	".c++":         "text/plain",
-	".c":           "text/x-c",
-	".cab":         "application/vnd.ms-cab-compressed",
-	".cat":         "application/vndms-pkiseccat",
-	".cc":          "text/x-c",
-	".ccad":        "application/clariscad",
-	".cco":         "application/x-cocoa",
-	".cdf":         "application/cdf",
-	".cer":         "application/pkix-cert",
-	".cha":         "application/x-chat",
-	".chat":        "application/x-chat",
-	".chrt":        "application/vnd.kde.kchart",
-	".class":       "application/java",
-	".com":         "text/plain",
-	".conf":        "text/plain",
-	".cpio":        "application/x-cpio",
-	".cpp":         "text/x-c",
-	".cpt":         "application/mac-compactpro",
-	".crl":         "application/pkcs-crl",
-	".crt":         "application/pkix-cert",
-	".crx":         "application/x-chrome-extension",
-	".csh":         "text/x-scriptcsh",
-	".css":         "text/css;charset=utf-8",
-	".csv":         "text/csv",
-	".cxx":         "text/plain",
-	".dar":         "application/x-dar",
-	".dcr":         "application/x-director",
-	".deb":         "application/x-debian-package",
-	".deepv":       "application/x-deepv",
-	".def":         "text/plain",
-	".der":         "application/x-x509-ca-cert",
-	".dif":         "video/x-dv",
-	".dir":         "application/x-director",
-	".divx":        "video/divx",
-	".dl":          "video/dl",
-	".dmg":         "application/x-apple-diskimage",
-	".doc":         "application/msword",
-	".dot":         "application/msword",
-	".dp":          "application/commonground",
-	".drw":         "application/drafting",
-	".dump":        "application/octet-stream",
-	".dv":          "video/x-dv",
-	".dvi":         "application/x-dvi",
-	".dwf":         "drawing/x-dwf=(old)",
-	".dwg":         "application/acad",
-	".dxf":         "application/dxf",
-	".dxr":         "application/x-director",
-	".el":          "text/x-scriptelisp",
-	".elc":         "application/x-bytecodeelisp=(compiled=elisp)",
-	".eml":         "message/rfc822",
-	".env":         "application/x-envoy",
-	".eps":         "application/postscript",
-	".es":          "application/x-esrehber",
-	".etx":         "text/x-setext",
-	".evy":         "application/envoy",
-	".exe":         "application/octet-stream",
-	".f77":         "text/x-fortran",
-	".f90":         "text/x-fortran",
-	".f":           "text/x-fortran",
-	".fdf":         "application/vndfdf",
-	".fif":         "application/fractals",
-	".fli":         "video/fli",
-	".flo":         "image/florian",
-	".flv":         "video/x-flv",
-	".flx":         "text/vndfmiflexstor",
-	".fmf":         "video/x-atomic3d-feature",
-	".for":         "text/x-fortran",
-	".fpx":         "image/vndfpx",
-	".frl":         "application/freeloader",
-	".funk":        "audio/make",
-	".g3":          "image/g3fax",
-	".g":           "text/plain",
-	".gif":         "image/gif",
-	".gl":          "video/gl",
-	".gsd":         "audio/x-gsm",
-	".gsm":         "audio/x-gsm",
-	".gsp":         "application/x-gsp",
-	".gss":         "application/x-gss",
-	".gtar":        "application/x-gtar",
-	".gz":          "application/x-compressed",
-	".gzip":        "application/x-gzip",
-	".h":           "text/x-h",
-	".hdf":         "application/x-hdf",
-	".help":        "application/x-helpfile",
-	".hgl":         "application/vndhp-hpgl",
-	".hh":          "text/x-h",
-	".hlb":         "text/x-script",
-	".hlp":         "application/hlp",
-	".hpg":         "application/vndhp-hpgl",
-	".hpgl":        "application/vndhp-hpgl",
-	".hqx":         "application/binhex",
-	".hta":         "application/hta",
-	".htc":         "text/x-component",
-	".htm":         "text/html;charset=utf-8",
-	".html":        "text/html;charset=utf-8",
-	".htmls":       "text/html",
-	".htt":         "text/webviewhtml",
-	".htx":         "text/html",
-	".ice":         "x-conference/x-cooltalk",
-	".ico":         "image/x-icon",
-	".ics":         "text/calendar",
-	".icz":         "text/calendar",
-	".idc":         "text/plain",
-	".ief":         "image/ief",
-	".iefs":        "image/ief",
-	".iges":        "application/iges",
-	".igs":         "application/iges",
-	".ima":         "application/x-ima",
-	".imap":        "application/x-httpd-imap",
-	".inf":         "application/inf",
-	".ins":         "application/x-internett-signup",
-	".ip":          "application/x-ip2",
-	".isu":         "video/x-isvideo",
-	".it":          "audio/it",
-	".iv":          "application/x-inventor",
-	".ivr":         "i-world/i-vrml",
-	".ivy":         "application/x-livescreen",
-	".jam":         "audio/x-jam",
-	".jav":         "text/x-java-source",
-	".java":        "text/x-java-source",
-	".jcm":         "application/x-java-commerce",
-	".jfif-tbnl":   "image/jpeg",
-	".jfif":        "image/jpeg",
-	".jnlp":        "application/x-java-jnlp-file",
-	".jpe":         "image/jpeg",
-	".jpeg":        "image/jpeg",
-	".jpg":         "image/jpeg",
-	".jps":         "image/x-jps",
-	".js":          "application/javascript;charset=utf-8",
-	".json":        "application/json",
-	".jut":         "image/jutvision",
-	".kar":         "audio/midi",
-	".karbon":      "application/vnd.kde.karbon",
-	".kfo":         "application/vnd.kde.kformula",
-	".flw":         "application/vnd.kde.kivio",
-	".kml":         "application/vnd.google-earth.kml+xml",
-	".kmz":         "application/vnd.google-earth.kmz",
-	".kon":         "application/vnd.kde.kontour",
-	".kpr":         "application/vnd.kde.kpresenter",
-	".kpt":         "application/vnd.kde.kpresenter",
-	".ksp":         "application/vnd.kde.kspread",
-	".kwd":         "application/vnd.kde.kword",
-	".kwt":         "application/vnd.kde.kword",
-	".ksh":         "text/x-scriptksh",
-	".la":          "audio/nspaudio",
-	".lam":         "audio/x-liveaudio",
-	".latex":       "application/x-latex",
-	".lha":         "application/lha",
-	".lhx":         "application/octet-stream",
-	".list":        "text/plain",
-	".lma":         "audio/nspaudio",
-	".log":         "text/plain",
-	".lsp":         "text/x-scriptlisp",
-	".lst":         "text/plain",
-	".lsx":         "text/x-la-asf",
-	".ltx":         "application/x-latex",
-	".lzh":         "application/octet-stream",
-	".lzx":         "application/lzx",
-	".m1v":         "video/mpeg",
-	".m2a":         "audio/mpeg",
-	".m2v":         "video/mpeg",
-	".m3u":         "audio/x-mpegurl",
-	".m":           "text/x-m",
-	".man":         "application/x-troff-man",
-	".manifest":    "text/cache-manifest",
-	".map":         "application/x-navimap",
-	".mar":         "text/plain",
-	".mbd":         "application/mbedlet",
-	".mc$":         "application/x-magic-cap-package-10",
-	".mcd":         "application/mcad",
-	".mcf":         "text/mcf",
-	".mcp":         "application/netmc",
-	".me":          "application/x-troff-me",
-	".mht":         "message/rfc822",
-	".mhtml":       "message/rfc822",
-	".mid":         "application/x-midi",
-	".midi":        "application/x-midi",
-	".mif":         "application/x-frame",
-	".mime":        "message/rfc822",
-	".mjf":         "audio/x-vndaudioexplosionmjuicemediafile",
-	".mjpg":        "video/x-motion-jpeg",
-	".mm":          "application/base64",
-	".mme":         "application/base64",
-	".mod":         "audio/mod",
-	".moov":        "video/quicktime",
-	".mov":         "video/quicktime",
-	".movie":       "video/x-sgi-movie",
-	".mp2":         "audio/mpeg",
-	".mp3":         "audio/mpeg3",
-	".mp4":         "video/mp4",
-	".mpa":         "audio/mpeg",
-	".mpc":         "application/x-project",
-	".mpe":         "video/mpeg",
-	".mpeg":        "video/mpeg",
-	".mpg":         "video/mpeg",
-	".mpga":        "audio/mpeg",
-	".mpp":         "application/vndms-project",
-	".mpt":         "application/x-project",
-	".mpv":         "application/x-project",
-	".mpx":         "application/x-project",
-	".mrc":         "application/marc",
-	".ms":          "application/x-troff-ms",
-	".mv":          "video/x-sgi-movie",
-	".my":          "audio/make",
-	".mzz":         "application/x-vndaudioexplosionmzz",
-	".nap":         "image/naplps",
-	".naplps":      "image/naplps",
-	".nc":          "application/x-netcdf",
-	".ncm":         "application/vndnokiaconfiguration-message",
-	".nif":         "image/x-niff",
-	".niff":        "image/x-niff",
-	".nix":         "application/x-mix-transfer",
-	".nsc":         "application/x-conference",
-	".nvd":         "application/x-navidoc",
-	".o":           "application/octet-stream",
-	".oda":         "application/oda",
-	".odb":         "application/vnd.oasis.opendocument.database",
-	".odc":         "application/vnd.oasis.opendocument.chart",
-	".odf":         "application/vnd.oasis.opendocument.formula",
-	".odg":         "application/vnd.oasis.opendocument.graphics",
-	".odi":         "application/vnd.oasis.opendocument.image",
-	".odm":         "application/vnd.oasis.opendocument.text-master",
-	".odp":         "application/vnd.oasis.opendocument.presentation",
-	".ods":         "application/vnd.oasis.opendocument.spreadsheet",
-	".odt":         "application/vnd.oasis.opendocument.text",
-	".oga":         "audio/ogg",
-	".ogg":         "audio/ogg",
-	".ogv":         "video/ogg",
-	".omc":         "application/x-omc",
-	".omcd":        "application/x-omcdatamaker",
-	".omcr":        "application/x-omcregerator",
-	".otc":         "application/vnd.oasis.opendocument.chart-template",
-	".otf":         "application/vnd.oasis.opendocument.formula-template",
-	".otg":         "application/vnd.oasis.opendocument.graphics-template",
-	".oth":         "application/vnd.oasis.opendocument.text-web",
-	".oti":         "application/vnd.oasis.opendocument.image-template",
-	".otm":         "application/vnd.oasis.opendocument.text-master",
-	".otp":         "application/vnd.oasis.opendocument.presentation-template",
-	".ots":         "application/vnd.oasis.opendocument.spreadsheet-template",
-	".ott":         "application/vnd.oasis.opendocument.text-template",
-	".p10":         "application/pkcs10",
-	".p12":         "application/pkcs-12",
-	".p7a":         "application/x-pkcs7-signature",
-	".p7c":         "application/pkcs7-mime",
-	".p7m":         "application/pkcs7-mime",
-	".p7r":         "application/x-pkcs7-certreqresp",
-	".p7s":         "application/pkcs7-signature",
-	".p":           "text/x-pascal",
-	".part":        "application/pro_eng",
-	".pas":         "text/pascal",
-	".pbm":         "image/x-portable-bitmap",
-	".pcl":         "application/vndhp-pcl",
-	".pct":         "image/x-pict",
-	".pcx":         "image/x-pcx",
-	".pdb":         "chemical/x-pdb",
-	".pdf":         "application/pdf",
-	".pfunk":       "audio/make",
-	".pgm":         "image/x-portable-graymap",
-	".pic":         "image/pict",
-	".pict":        "image/pict",
-	".pkg":         "application/x-newton-compatible-pkg",
-	".pko":         "application/vndms-pkipko",
-	".pl":          "text/x-scriptperl",
-	".plx":         "application/x-pixclscript",
-	".pm4":         "application/x-pagemaker",
-	".pm5":         "application/x-pagemaker",
-	".pm":          "text/x-scriptperl-module",
-	".png":         "image/png",
-	".pnm":         "application/x-portable-anymap",
-	".pot":         "application/mspowerpoint",
-	".pov":         "model/x-pov",
-	".ppa":         "application/vndms-powerpoint",
-	".ppm":         "image/x-portable-pixmap",
-	".pps":         "application/mspowerpoint",
-	".ppt":         "application/mspowerpoint",
-	".ppz":         "application/mspowerpoint",
-	".pre":         "application/x-freelance",
-	".prt":         "application/pro_eng",
-	".ps":          "application/postscript",
-	".psd":         "application/octet-stream",
-	".pvu":         "paleovu/x-pv",
-	".pwz":         "application/vndms-powerpoint",
-	".py":          "text/x-scriptphyton",
-	".pyc":         "applicaiton/x-bytecodepython",
-	".qcp":         "audio/vndqcelp",
-	".qd3":         "x-world/x-3dmf",
-	".qd3d":        "x-world/x-3dmf",
-	".qif":         "image/x-quicktime",
-	".qt":          "video/quicktime",
-	".qtc":         "video/x-qtc",
-	".qti":         "image/x-quicktime",
-	".qtif":        "image/x-quicktime",
-	".ra":          "audio/x-pn-realaudio",
-	".ram":         "audio/x-pn-realaudio",
-	".rar":         "application/x-rar-compressed",
-	".ras":         "application/x-cmu-raster",
-	".rast":        "image/cmu-raster",
-	".rexx":        "text/x-scriptrexx",
-	".rf":          "image/vndrn-realflash",
-	".rgb":         "image/x-rgb",
-	".rm":          "application/vndrn-realmedia",
-	".rmi":         "audio/mid",
-	".rmm":         "audio/x-pn-realaudio",
-	".rmp":         "audio/x-pn-realaudio",
-	".rng":         "application/ringing-tones",
-	".rnx":         "application/vndrn-realplayer",
-	".roff":        "application/x-troff",
-	".rp":          "image/vndrn-realpix",
-	".rpm":         "audio/x-pn-realaudio-plugin",
-	".rt":          "text/vndrn-realtext",
-	".rtf":         "text/richtext",
-	".rtx":         "text/richtext",
-	".rv":          "video/vndrn-realvideo",
-	".s":           "text/x-asm",
-	".s3m":         "audio/s3m",
-	".s7z":         "application/x-7z-compressed",
-	".saveme":      "application/octet-stream",
-	".sbk":         "application/x-tbook",
-	".scm":         "text/x-scriptscheme",
-	".sdml":        "text/plain",
-	".sdp":         "application/sdp",
-	".sdr":         "application/sounder",
-	".sea":         "application/sea",
-	".set":         "application/set",
-	".sgm":         "text/x-sgml",
-	".sgml":        "text/x-sgml",
-	".sh":          "text/x-scriptsh",
-	".shar":        "application/x-bsh",
-	".shtml":       "text/x-server-parsed-html",
-	".sid":         "audio/x-psid",
-	".skd":         "application/x-koan",
-	".skm":         "application/x-koan",
-	".skp":         "application/x-koan",
-	".skt":         "application/x-koan",
-	".sit":         "application/x-stuffit",
-	".sitx":        "application/x-stuffitx",
-	".sl":          "application/x-seelogo",
-	".smi":         "application/smil",
-	".smil":        "application/smil",
-	".snd":         "audio/basic",
-	".sol":         "application/solids",
-	".spc":         "text/x-speech",
-	".spl":         "application/futuresplash",
-	".spr":         "application/x-sprite",
-	".sprite":      "application/x-sprite",
-	".spx":         "audio/ogg",
-	".src":         "application/x-wais-source",
-	".ssi":         "text/x-server-parsed-html",
-	".ssm":         "application/streamingmedia",
-	".sst":         "application/vndms-pkicertstore",
-	".step":        "application/step",
-	".stl":         "application/sla",
-	".stp":         "application/step",
-	".sv4cpio":     "application/x-sv4cpio",
-	".sv4crc":      "application/x-sv4crc",
-	".svf":         "image/vnddwg",
-	".svg":         "image/svg+xml",
-	".svr":         "application/x-world",
-	".swf":         "application/x-shockwave-flash",
-	".t":           "application/x-troff",
-	".talk":        "text/x-speech",
-	".tar":         "application/x-tar",
-	".tbk":         "application/toolbook",
-	".tcl":         "text/x-scripttcl",
-	".tcsh":        "text/x-scripttcsh",
-	".tex":         "application/x-tex",
-	".texi":        "application/x-texinfo",
-	".texinfo":     "application/x-texinfo",
-	".text":        "text/plain",
-	".tgz":         "application/gnutar",
-	".tif":         "image/tiff",
-	".tiff":        "image/tiff",
-	".tr":          "application/x-troff",
-	".tsi":         "audio/tsp-audio",
-	".tsp":         "application/dsptype",
-	".tsv":         "text/tab-separated-values",
-	".turbot":      "image/florian",
-	".txt":         "text/plain",
-	".uil":         "text/x-uil",
-	".uni":         "text/uri-list",
-	".unis":        "text/uri-list",
-	".unv":         "application/i-deas",
-	".uri":         "text/uri-list",
-	".uris":        "text/uri-list",
-	".ustar":       "application/x-ustar",
-	".uu":          "text/x-uuencode",
-	".uue":         "text/x-uuencode",
-	".vcd":         "application/x-cdlink",
-	".vcf":         "text/x-vcard",
-	".vcard":       "text/x-vcard",
-	".vcs":         "text/x-vcalendar",
-	".vda":         "application/vda",
-	".vdo":         "video/vdo",
-	".vew":         "application/groupwise",
-	".viv":         "video/vivo",
-	".vivo":        "video/vivo",
-	".vmd":         "application/vocaltec-media-desc",
-	".vmf":         "application/vocaltec-media-file",
-	".voc":         "audio/voc",
-	".vos":         "video/vosaic",
-	".vox":         "audio/voxware",
-	".vqe":         "audio/x-twinvq-plugin",
-	".vqf":         "audio/x-twinvq",
-	".vql":         "audio/x-twinvq-plugin",
-	".vrml":        "application/x-vrml",
-	".vrt":         "x-world/x-vrt",
-	".vsd":         "application/x-visio",
-	".vst":         "application/x-visio",
-	".vsw":         "application/x-visio",
-	".w60":         "application/wordperfect60",
-	".w61":         "application/wordperfect61",
-	".w6w":         "application/msword",
-	".wav":         "audio/wav",
-	".wb1":         "application/x-qpro",
-	".wbmp":        "image/vnd.wap.wbmp",
-	".web":         "application/vndxara",
-	".wiz":         "application/msword",
-	".wk1":         "application/x-123",
-	".wmf":         "windows/metafile",
-	".wml":         "text/vnd.wap.wml",
-	".wmlc":        "application/vnd.wap.wmlc",
-	".wmls":        "text/vnd.wap.wmlscript",
-	".wmlsc":       "application/vnd.wap.wmlscriptc",
-	".word":        "application/msword",
-	".wp5":         "application/wordperfect",
-	".wp6":         "application/wordperfect",
-	".wp":          "application/wordperfect",
-	".wpd":         "application/wordperfect",
-	".wq1":         "application/x-lotus",
-	".wri":         "application/mswrite",
-	".wrl":         "application/x-world",
-	".wrz":         "model/vrml",
-	".wsc":         "text/scriplet",
-	".wsrc":        "application/x-wais-source",
-	".wtk":         "application/x-wintalk",
-	".x-png":       "image/png",
-	".xbm":         "image/x-xbitmap",
-	".xdr":         "video/x-amt-demorun",
-	".xgz":         "xgl/drawing",
-	".xif":         "image/vndxiff",
-	".xl":          "application/excel",
-	".xla":         "application/excel",
-	".xlb":         "application/excel",
-	".xlc":         "application/excel",
-	".xld":         "application/excel",
-	".xlk":         "application/excel",
-	".xll":         "application/excel",
-	".xlm":         "application/excel",
-	".xls":         "application/excel",
-	".xlt":         "application/excel",
-	".xlv":         "application/excel",
-	".xlw":         "application/excel",
-	".xm":          "audio/xm",
-	".xml":         "text/xml",
-	".xmz":         "xgl/movie",
-	".xpix":        "application/x-vndls-xpix",
-	".xpm":         "image/x-xpixmap",
-	".xsr":         "video/x-amt-showrun",
-	".xwd":         "image/x-xwd",
-	".xyz":         "chemical/x-pdb",
-	".z":           "application/x-compress",
-	".zip":         "application/zip",
-	".zoo":         "application/octet-stream",
-	".zsh":         "text/x-scriptzsh",
-	".docx":        "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-	".docm":        "application/vnd.ms-word.document.macroEnabled.12",
-	".dotx":        "application/vnd.openxmlformats-officedocument.wordprocessingml.template",
-	".dotm":        "application/vnd.ms-word.template.macroEnabled.12",
-	".xlsx":        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-	".xlsm":        "application/vnd.ms-excel.sheet.macroEnabled.12",
-	".xltx":        "application/vnd.openxmlformats-officedocument.spreadsheetml.template",
-	".xltm":        "application/vnd.ms-excel.template.macroEnabled.12",
-	".xlsb":        "application/vnd.ms-excel.sheet.binary.macroEnabled.12",
-	".xlam":        "application/vnd.ms-excel.addin.macroEnabled.12",
-	".pptx":        "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-	".pptm":        "application/vnd.ms-powerpoint.presentation.macroEnabled.12",
-	".ppsx":        "application/vnd.openxmlformats-officedocument.presentationml.slideshow",
-	".ppsm":        "application/vnd.ms-powerpoint.slideshow.macroEnabled.12",
-	".potx":        "application/vnd.openxmlformats-officedocument.presentationml.template",
-	".potm":        "application/vnd.ms-powerpoint.template.macroEnabled.12",
-	".ppam":        "application/vnd.ms-powerpoint.addin.macroEnabled.12",
-	".sldx":        "application/vnd.openxmlformats-officedocument.presentationml.slide",
-	".sldm":        "application/vnd.ms-powerpoint.slide.macroEnabled.12",
-	".thmx":        "application/vnd.ms-officetheme",
-	".onetoc":      "application/onenote",
-	".onetoc2":     "application/onenote",
-	".onetmp":      "application/onenote",
-	".onepkg":      "application/onenote",
-	".key":         "application/x-iwork-keynote-sffkey",
-	".kth":         "application/x-iwork-keynote-sffkth",
-	".nmbtemplate": "application/x-iwork-numbers-sfftemplate",
-	".numbers":     "application/x-iwork-numbers-sffnumbers",
-	".pages":       "application/x-iwork-pages-sffpages",
-	".template":    "application/x-iwork-pages-sfftemplate",
-	".xpi":         "application/x-xpinstall",
-	".oex":         "application/x-opera-extension",
-	".mustache":    "text/html",
-}

vendor/code.hoteas.com/golang/hotime/obj.go

@@ -1,93 +0,0 @@
-package hotime
-
-//对象封装方便取用
-type Obj struct {
-	Data interface{}
-	contextBase
-}
-
-func (this *Obj) Put(data interface{}) {
-	this.Data = data
-}
-
-func (this *Obj) ToInt(err ...Error) int {
-	if len(err) != 0 {
-		this.Error = err[0]
-	}
-	return ObjToInt(this.Data, &this.Error)
-}
-
-func (this *Obj) ToInt64(err ...Error) int64 {
-	if len(err) != 0 {
-		this.Error = err[0]
-	}
-	return ObjToInt64(this.Data, &this.Error)
-}
-
-func (this *Obj) ToFloat64(err ...Error) float64 {
-	if len(err) != 0 {
-		this.Error = err[0]
-	}
-	return ObjToFloat64(this.Data, &this.Error)
-}
-
-//获取向上取整float64
-func (this *Obj) ToCeilFloat64(err ...*Error) float64 {
-	if len(err) != 0 {
-		this.Error = *err[0]
-	}
-	v := ObjToCeilFloat64(this.Data, err...)
-	return v
-
-}
-
-func (this *Obj) ToStr() string {
-
-	return ObjToStr(this.Data)
-}
-
-func (this *Obj) ToMap(err ...Error) Map {
-	if len(err) != 0 {
-		this.Error = err[0]
-	}
-	return ObjToMap(this.Data, &this.Error)
-}
-
-func (this *Obj) ToSlice(err ...Error) Slice {
-	if len(err) != 0 {
-		this.Error = err[0]
-	}
-	return ObjToSlice(this.Data, &this.Error)
-}
-
-func (this *Obj) ToMapArray(err ...Error) []Map {
-	if len(err) != 0 {
-		this.Error = err[0]
-	}
-	return ObjToMapArray(this.Data, &this.Error)
-}
-
-func (this *Obj) ToObj() interface{} {
-
-	return this.Data
-}
-
-//获取向上取整Int64
-func (this *Obj) ToCeilInt64(err ...*Error) int64 {
-	if len(err) != 0 {
-		this.Error = *err[0]
-	}
-	v := ObjToCeilInt64(this.Data, err...)
-	return v
-
-}
-
-//获取向上取整Int
-func (this *Obj) ToCeilInt(err ...*Error) int {
-	if len(err) != 0 {
-		this.Error = *err[0]
-	}
-	v := ObjToCeilInt(this.Data, err...)
-	return v
-
-}

vendor/code.hoteas.com/golang/hotime/objtoobj.go

@@ -1,294 +0,0 @@
-package hotime
-
-import (
-	"encoding/json"
-	"errors"
-	"math"
-	"strconv"
-)
-
-//仅限于hotime.Slice
-func ObjToMap(obj interface{}, e ...*Error) Map {
-	var err error
-	var v Map
-
-	if obj == nil {
-		v = nil
-		err = errors.New("没有合适的转换对象！")
-	} else {
-		switch obj.(type) {
-		case Map:
-			v = obj.(Map)
-		case map[string]interface{}:
-			v = obj.(map[string]interface{})
-		case string:
-			v = Map{}
-			e := json.Unmarshal([]byte(obj.(string)), &v)
-			if e != nil {
-				err = errors.New("没有合适的转换对象！" + e.Error())
-				v = nil
-			}
-		default:
-			data, err := json.Marshal(obj)
-			if err != nil {
-				err = errors.New("没有合适的转换对象！" + err.Error())
-				v = nil
-			}
-			v = Map{}
-			e := json.Unmarshal(data, &v)
-			if e != nil {
-				err = errors.New("没有合适的转换对象！" + e.Error())
-				v = nil
-			}
-
-		}
-	}
-	if len(e) != 0 {
-		e[0].SetError(err)
-	}
-	return v
-}
-
-func ObjToMapArray(obj interface{}, e ...*Error) []Map {
-	s := ObjToSlice(obj, e...)
-	res := []Map{}
-	for i := 0; i < len(s); i++ {
-		res = append(res, s.GetMap(i))
-	}
-	return res
-}
-
-//仅限于hotime.Slice
-func ObjToSlice(obj interface{}, e ...*Error) Slice {
-	var err error
-	var v Slice
-
-	if obj == nil {
-		v = nil
-		err = errors.New("没有合适的转换对象！")
-	} else {
-		switch obj.(type) {
-		case Slice:
-			v = obj.(Slice)
-		case []interface{}:
-			v = obj.([]interface{})
-		case []string:
-			v = Slice{}
-			for i := 0; i < len(obj.([]string)); i++ {
-				v = append(v, obj.([]string)[i])
-			}
-		case string:
-			v = Slice{}
-			err = json.Unmarshal([]byte(obj.(string)), &v)
-
-		default:
-			v = Slice{}
-			var data []byte
-			data, err = json.Marshal(obj)
-			err = json.Unmarshal(data, &v)
-		}
-	}
-
-	if len(e) != 0 {
-		e[0].SetError(err)
-	}
-
-	return v
-}
-
-func ObjToFloat64(obj interface{}, e ...*Error) float64 {
-	var err error
-	v := float64(0)
-
-	if obj == nil {
-
-		err = errors.New("没有合适的转换对象！")
-	} else {
-
-		switch obj.(type) {
-		case int:
-			v = float64(obj.(int))
-		case int64:
-			v = float64(obj.(int64))
-		case string:
-			value, e := strconv.ParseFloat(obj.(string), 64)
-			if e != nil {
-				v = float64(0)
-				err = e
-			} else {
-				v = value
-			}
-		case float64:
-			v = obj.(float64)
-		case float32:
-			v = float64(obj.(float32))
-		case uint8:
-			value, e := strconv.ParseFloat(obj.(string), 64)
-			if e != nil {
-				v = float64(0)
-				err = e
-			} else {
-				v = value
-			}
-		default:
-			v = float64(0)
-			err = errors.New("没有合适的转换对象！")
-		}
-	}
-	if len(e) != 0 {
-		e[0].SetError(err)
-	}
-
-	return v
-}
-
-//向上取整
-func ObjToCeilInt64(obj interface{}, e ...*Error) int64 {
-	f := ObjToCeilFloat64(obj, e...)
-	return ObjToInt64(math.Ceil(f))
-
-}
-
-//向上取整
-func ObjToCeilFloat64(obj interface{}, e ...*Error) float64 {
-	f := ObjToFloat64(obj, e...)
-	return math.Ceil(f)
-
-}
-
-//向上取整
-func ObjToCeilInt(obj interface{}, e ...*Error) int {
-	f := ObjToCeilFloat64(obj, e...)
-	return ObjToInt(f)
-
-}
-
-func ObjToInt64(obj interface{}, e ...*Error) int64 {
-	var err error
-	v := int64(0)
-
-	if obj == nil {
-
-		err = errors.New("没有合适的转换对象！")
-	} else {
-		switch obj.(type) {
-		case int:
-			v = int64(obj.(int))
-		case int64:
-			v = obj.(int64)
-		case string:
-			value, e := StrToInt(obj.(string))
-			if e != nil {
-				v = int64(0)
-				err = e
-			} else {
-				v = int64(value)
-			}
-		case uint8:
-			value, e := StrToInt(obj.(string))
-			if e != nil {
-				v = int64(0)
-				err = e
-			} else {
-				v = int64(value)
-			}
-		case float64:
-			v = int64(obj.(float64))
-		case float32:
-			v = int64(obj.(float32))
-		default:
-			v = int64(0)
-			err = errors.New("没有合适的转换对象！")
-		}
-	}
-	if len(e) != 0 {
-		e[0].SetError(err)
-	}
-	return v
-}
-
-func ObjToInt(obj interface{}, e ...*Error) int {
-	v := ObjToInt64(obj, e...)
-	return int(v)
-}
-
-func ObjToStr(obj interface{}) string {
-	//	fmt.Println(reflect.ValueOf(obj).Type().String() )
-	str := ""
-	if obj == nil {
-		return str
-	}
-	switch obj.(type) {
-	case int:
-		str = strconv.Itoa(obj.(int))
-	case uint8:
-		str = obj.(string)
-	case int64:
-		str = strconv.FormatInt(obj.(int64), 10)
-	case []byte:
-		str = string(obj.([]byte))
-	case string:
-		str = obj.(string)
-	case float64:
-		str = strconv.FormatFloat(obj.(float64), 'f', -1, 64)
-	default:
-		strbte, err := json.Marshal(obj)
-		if err == nil {
-			str = string(strbte)
-		}
-
-	}
-
-	return str
-}
-
-//转换为Map
-func StrToMap(string string) Map {
-	data := Map{}
-	data.JsonToMap(string)
-
-	return data
-}
-
-//转换为Slice
-func StrToSlice(string string) Slice {
-
-	data := ObjToSlice(string)
-
-	return data
-}
-
-//字符串数组: a1,a2,a3转["a1","a2","a3"]
-func StrArrayToJsonStr(a string) string {
-
-	if len(a) > 2 {
-		if a[0] == ',' {
-			a = Substr(a, 1, len(a)-1)
-		}
-		if a[len(a)-1] == ',' {
-			a = Substr(a, 0, len(a)-1)
-		}
-		//a = strings.Replace(a, ",", `,`, -1)
-		a = `[` + a + `]`
-	} else {
-		a = "[]"
-	}
-	return a
-}
-
-//字符串数组: a1,a2,a3转["a1","a2","a3"]
-func JsonStrToStrArray(a string) string {
-	//a = strings.Replace(a, `"`, "", -1)
-	if len(a) != 0 {
-		a = Substr(a, 1, len(a)-2)
-	}
-
-	return "," + a + ","
-}
-
-//字符串转int
-func StrToInt(s string) (int, error) {
-	i, err := strconv.Atoi(s)
-	return i, err
-
-}

vendor/code.hoteas.com/golang/hotime/session.go

@@ -1,71 +0,0 @@
-package hotime
-
-//session对象
-type SessionIns struct {
-	ShortCache CacheIns
-	LongCache  CacheIns
-	SessionId  string
-	Map
-	contextBase
-}
-
-func (this *SessionIns) set() {
-
-	if this.ShortCache != nil {
-		this.ShortCache.Cache(HEAD_SESSION_ADD+this.SessionId, this.Map)
-	}
-	if this.LongCache != nil {
-		this.LongCache.Cache(HEAD_SESSION_ADD+this.SessionId, this.Map)
-	}
-
-}
-
-func (this *SessionIns) Session(key string, data ...interface{}) *Obj {
-
-	if this.Map == nil {
-		this.get()
-	}
-
-	if len(data) != 0 {
-		if data[0] == nil {
-			delete(this.Map, key)
-			this.set()
-		} else {
-			this.Map[key] = data[0]
-			this.set()
-		}
-		return &Obj{Data: nil}
-	}
-
-	return &Obj{Data: this.Map.Get(key)}
-
-}
-
-func (this *SessionIns) get() {
-
-	if this.ShortCache != nil {
-		this.Map = this.ShortCache.Cache(HEAD_SESSION_ADD + this.SessionId).ToMap()
-		if this.Map != nil {
-			return
-		}
-	}
-
-	if this.LongCache != nil {
-		this.Map = this.LongCache.Cache(HEAD_SESSION_ADD + this.SessionId).ToMap()
-		if this.Map != nil {
-			if this.ShortCache != nil {
-				this.ShortCache.Cache(HEAD_SESSION_ADD+this.SessionId, this.Map)
-			}
-			return
-		}
-	}
-	this.Map = Map{}
-	this.ShortCache.Cache(HEAD_SESSION_ADD+this.SessionId, this.Map)
-
-	return
-}
-
-func (this *SessionIns) Init(short CacheIns, long CacheIns) {
-	this.ShortCache = short
-	this.LongCache = long
-}

vendor/code.hoteas.com/golang/hotime/slice.go

@@ -1,87 +0,0 @@
-package hotime
-
-import (
-	"errors"
-)
-
-type Slice []interface{}
-
-//获取string
-func (this Slice) GetString(key int, err ...*Error) string {
-	if len(err) != 0 {
-		err[0].SetError(nil)
-	}
-	return ObjToStr((this)[key])
-}
-
-//获取Int
-func (this Slice) GetInt(key int, err ...*Error) int {
-	v := ObjToInt((this)[key], err...)
-	return v
-}
-
-//获取Int
-func (this Slice) GetInt64(key int, err ...*Error) int64 {
-	v := ObjToInt64((this)[key], err...)
-
-	return v
-}
-
-//获取向上取整Int64
-func (this Slice) GetCeilInt64(key int, err ...*Error) int64 {
-	v := ObjToCeilInt64((this)[key], err...)
-	return v
-
-}
-
-//获取向上取整Int
-func (this Slice) GetCeilInt(key int, err ...*Error) int {
-	v := ObjToCeilInt((this)[key], err...)
-	return v
-
-}
-
-//获取向上取整float64
-func (this Slice) GetCeilFloat64(key int, err ...*Error) float64 {
-	v := ObjToCeilFloat64((this)[key], err...)
-	return v
-
-}
-
-//获取Float64
-func (this Slice) GetFloat64(key int, err ...*Error) float64 {
-	v := ObjToFloat64((this)[key], err...)
-
-	return v
-}
-
-func (this Slice) GetSlice(key int, err ...*Error) Slice {
-	v := ObjToSlice((this)[key], err...)
-	return v
-}
-
-func (this Slice) GetMap(key int, err ...*Error) Map {
-	//var v Map
-	v := ObjToMap((this)[key], err...)
-	return v
-}
-
-func (this Slice) Get(key int, err ...*Error) interface{} {
-
-	if key < len(this) {
-		return this[key]
-	}
-	e := errors.New("没有存储key及对应的数据")
-	if len(err) != 0 {
-		err[0].SetError(e)
-	}
-	return nil
-}
-
-func (this Slice) Put(key int, value interface{}) {
-	this[key] = value
-}
-
-func (this Slice) ToJsonString() string {
-	return ObjToStr(this)
-}

vendor/code.hoteas.com/golang/hotime/tools/db/auto.go

@@ -1,18 +0,0 @@
-package db
-
-import (
-	"code.hoteas.com/golang/hotime"
-	"code.hoteas.com/golang/hotime/tools/mysql"
-	"code.hoteas.com/golang/hotime/tools/sqlite"
-	"strings"
-)
-
-func SetDB(appIns *hotime.Application) {
-	if appIns.Config.GetString("dbType") == "sqlite" || strings.Index(appIns.Config.GetString("dbName"), ".db") == len(appIns.Config.GetString("dbName"))-3 {
-		appIns.Config["dbType"] = "sqlite"
-		sqlite.SetDB(appIns)
-	} else {
-		appIns.Config["dbType"] = "mysql"
-		mysql.SetDB(appIns)
-	}
-}

vendor/code.hoteas.com/golang/hotime/tools/mysql/mysql.go

@@ -1,19 +0,0 @@
-package mysql
-
-import (
-	"code.hoteas.com/golang/hotime"
-	"database/sql"
-	_ "github.com/go-sql-driver/mysql"
-)
-
-func SetDB(appIns *hotime.Application) {
-	appIns.SetConnectDB(func(err ...*hotime.Error) *sql.DB {
-		query := appIns.Config.GetString("dbUser") + ":" + appIns.Config.GetString("dbPwd") +
-			"@tcp(" + appIns.Config.GetString("dbHost") + ":" + appIns.Config.GetString("dbPort") + ")/" + appIns.Config.GetString("dbName") + "?charset=utf8"
-		DB, e := sql.Open("mysql", query)
-		if e != nil && len(err) != 0 {
-			err[0].SetError(e)
-		}
-		return DB
-	})
-}

vendor/code.hoteas.com/golang/hotime/tools/sqlite/sqlite.go

@@ -1,17 +0,0 @@
-package sqlite
-
-import (
-	"code.hoteas.com/golang/hotime"
-	"database/sql"
-	_ "github.com/mattn/go-sqlite3"
-)
-
-func SetDB(appIns *hotime.Application) {
-	appIns.SetConnectDB(func(err ...*hotime.Error) *sql.DB {
-		db, e := sql.Open("sqlite3", appIns.Config.GetString("dbName"))
-		if e != nil && len(err) != 0 {
-			err[0].SetError(e)
-		}
-		return db
-	})
-}

vendor/code.hoteas.com/golang/hotime/var.go

@@ -1,70 +0,0 @@
-package hotime
-
-var IsRun = false                   //当前状态
-var App = map[string]*Application{} //整个项目
-
-//var Db = HoTimeDB{}                         //数据库实例
-
-var Config = Map{
-	"debug":          1, //debug 0关闭1开启
-	"logLevel":       LOG_FMT,
-	"dbHost":         "127.0.0.1",
-	"dbName":         "test",
-	"dbUser":         "root",
-	"dbPwd":          "root",
-	"dbPort":         "3306",
-	"dbCached":       0, //0不开启缓存
-	"cacheShortTime": 60 * 60 * 2,
-	"cacheLongTime":  60 * 60 * 24 * 30,
-	"error": Map{
-		"1": "内部系统异常",
-		"2": "访问权限异常",
-		"3": "请求参数异常",
-		"4": "数据处理异常",
-		"5": "数据结果异常",
-	},
-	"tpt":              "tpt",
-	"defFile":          []string{"index.html", "index.htm"},
-	"modeRouterStrict": false, //路由严格模式/a/b/c
-	"port":             "80",
-	"sessionName":      "HOTIME",
-	"tlsPort":          "0",
-	"tlsKey":           "",
-	"tlsCert":          "",
-}
-
-var ConfigNote = Map{
-	"logLevel":       "日志等级，0关闭，1打印",
-	"logFile":        "如果需要存储日志文件时使用，保存格式为:a/b/c/20060102150405.txt,将生成：a/b/c/年月日时分秒.txt，按需设置",
-	"debug":          "是否开启debug模式，0关闭，其他开启，debug模式下日志展示更全", //debug 0关闭1开启
-	"dbHost":         "数据库ip地址默认127.0.0.1",
-	"dbName":         "数据库名称，sqlite为文件路径比如a/x.db",
-	"dbUser":         "数据库用户名",
-	"dbPwd":          "数据库密码",
-	"dbPort":         "数据库端口",
-	"dbType":         "如果需要使用自动数据库配置，请设置此项，手动配置数据库不需要，目前支持mysql，sqlite",
-	"dbCached":       "是否开启数据库缓存0为关闭，其他开启", //0不开启缓存
-	"redisHost":      "如果需要使用redis服务时配置，默认服务ip：127.0.0.1",
-	"redisPort":      "如果需要使用redis服务时配置，默认服务端口：6379",
-	"redisPwd":       "如果需要使用redis服务时配置，默认服务密码：123456",
-	"cacheShortTime": "两级缓存，短缓存存储时间60 * 60 * 2，一般为内存缓存",
-	"cacheLongTime":  "两级缓存，长缓存存储时间60 * 60 * 24 * 30，一般为数据库或者redis缓存",
-	"error": Map{
-		"1":  "内部系统异常，在环境配置，文件访问权限等基础运行环境条件不足造成严重错误时使用",
-		"2":  "访问权限异常，没有登录或者登录异常等时候使用",
-		"3":  "请求参数异常，request参数不满足要求，比如参数不足，参数类型错误，参数不满足要求等时候使用",
-		"4":  "数据处理异常,数据库操作或者三方请求返回的结果非正常结果，比如数据库突然中断等时候使用",
-		"5":  "数据结果异常，一般用于无法给出response要求的格式要求下使用，比如response需要的是string格式但你只能提供int数据时",
-		"注释": "web服务内置错误提示，自定义异常建议10开始",
-	},
-	"tpt":              "静态文件目录，默认为程序目录下tpt目录",
-	"defFile":          "默认访问文件，默认访问index.html或者index.htm文件",
-	"crossDomain":      "如果需要跨域设置，空字符串为不开启，*为开启所有网站允许跨域，http://www.baidu.com为指定域允许跨域", //是否开启跨域
-	"modeRouterStrict": "路由严格模式false,为大小写忽略必须匹配，true必须大小写匹配",                          //路由严格模式/a/b/c
-	"connectLogShow":   "如果需要web访问链接、访问ip、访问时间打印，0为关闭其他数字开启此功能",
-	"sessionName":      "设置session的cookie名默认HOTIME",
-	"port":             "web服务开启Http端口，0为不启用http服务,默认80",
-	"tlsPort":          "web服务https端口，0为不启用https服务",
-	"tlsKey":           "https密钥",
-	"tlsCert":          "https证书",
-}

vendor/github.com/garyburd/redigo/LICENSE

@@ -1,175 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.

vendor/github.com/garyburd/redigo/internal/commandinfo.go

@@ -1,54 +0,0 @@
-// Copyright 2014 Gary Burd
-//
-// 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 internal // import "github.com/garyburd/redigo/internal"
-
-import (
-	"strings"
-)
-
-const (
-	WatchState = 1 << iota
-	MultiState
-	SubscribeState
-	MonitorState
-)
-
-type CommandInfo struct {
-	Set, Clear int
-}
-
-var commandInfos = map[string]CommandInfo{
-	"WATCH":      {Set: WatchState},
-	"UNWATCH":    {Clear: WatchState},
-	"MULTI":      {Set: MultiState},
-	"EXEC":       {Clear: WatchState | MultiState},
-	"DISCARD":    {Clear: WatchState | MultiState},
-	"PSUBSCRIBE": {Set: SubscribeState},
-	"SUBSCRIBE":  {Set: SubscribeState},
-	"MONITOR":    {Set: MonitorState},
-}
-
-func init() {
-	for n, ci := range commandInfos {
-		commandInfos[strings.ToLower(n)] = ci
-	}
-}
-
-func LookupCommandInfo(commandName string) CommandInfo {
-	if ci, ok := commandInfos[commandName]; ok {
-		return ci
-	}
-	return commandInfos[strings.ToUpper(commandName)]
-}

vendor/github.com/garyburd/redigo/redis/conn.go

@@ -1,673 +0,0 @@
-// Copyright 2012 Gary Burd
-//
-// 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 redis
-
-import (
-	"bufio"
-	"bytes"
-	"crypto/tls"
-	"errors"
-	"fmt"
-	"io"
-	"net"
-	"net/url"
-	"regexp"
-	"strconv"
-	"sync"
-	"time"
-)
-
-var (
-	_ ConnWithTimeout = (*conn)(nil)
-)
-
-// conn is the low-level implementation of Conn
-type conn struct {
-	// Shared
-	mu      sync.Mutex
-	pending int
-	err     error
-	conn    net.Conn
-
-	// Read
-	readTimeout time.Duration
-	br          *bufio.Reader
-
-	// Write
-	writeTimeout time.Duration
-	bw           *bufio.Writer
-
-	// Scratch space for formatting argument length.
-	// '*' or '$', length, "\r\n"
-	lenScratch [32]byte
-
-	// Scratch space for formatting integers and floats.
-	numScratch [40]byte
-}
-
-// DialTimeout acts like Dial but takes timeouts for establishing the
-// connection to the server, writing a command and reading a reply.
-//
-// Deprecated: Use Dial with options instead.
-func DialTimeout(network, address string, connectTimeout, readTimeout, writeTimeout time.Duration) (Conn, error) {
-	return Dial(network, address,
-		DialConnectTimeout(connectTimeout),
-		DialReadTimeout(readTimeout),
-		DialWriteTimeout(writeTimeout))
-}
-
-// DialOption specifies an option for dialing a Redis server.
-type DialOption struct {
-	f func(*dialOptions)
-}
-
-type dialOptions struct {
-	readTimeout  time.Duration
-	writeTimeout time.Duration
-	dialer       *net.Dialer
-	dial         func(network, addr string) (net.Conn, error)
-	db           int
-	password     string
-	useTLS       bool
-	skipVerify   bool
-	tlsConfig    *tls.Config
-}
-
-// DialReadTimeout specifies the timeout for reading a single command reply.
-func DialReadTimeout(d time.Duration) DialOption {
-	return DialOption{func(do *dialOptions) {
-		do.readTimeout = d
-	}}
-}
-
-// DialWriteTimeout specifies the timeout for writing a single command.
-func DialWriteTimeout(d time.Duration) DialOption {
-	return DialOption{func(do *dialOptions) {
-		do.writeTimeout = d
-	}}
-}
-
-// DialConnectTimeout specifies the timeout for connecting to the Redis server when
-// no DialNetDial option is specified.
-func DialConnectTimeout(d time.Duration) DialOption {
-	return DialOption{func(do *dialOptions) {
-		do.dialer.Timeout = d
-	}}
-}
-
-// DialKeepAlive specifies the keep-alive period for TCP connections to the Redis server
-// when no DialNetDial option is specified.
-// If zero, keep-alives are not enabled. If no DialKeepAlive option is specified then
-// the default of 5 minutes is used to ensure that half-closed TCP sessions are detected.
-func DialKeepAlive(d time.Duration) DialOption {
-	return DialOption{func(do *dialOptions) {
-		do.dialer.KeepAlive = d
-	}}
-}
-
-// DialNetDial specifies a custom dial function for creating TCP
-// connections, otherwise a net.Dialer customized via the other options is used.
-// DialNetDial overrides DialConnectTimeout and DialKeepAlive.
-func DialNetDial(dial func(network, addr string) (net.Conn, error)) DialOption {
-	return DialOption{func(do *dialOptions) {
-		do.dial = dial
-	}}
-}
-
-// DialDatabase specifies the database to select when dialing a connection.
-func DialDatabase(db int) DialOption {
-	return DialOption{func(do *dialOptions) {
-		do.db = db
-	}}
-}
-
-// DialPassword specifies the password to use when connecting to
-// the Redis server.
-func DialPassword(password string) DialOption {
-	return DialOption{func(do *dialOptions) {
-		do.password = password
-	}}
-}
-
-// DialTLSConfig specifies the config to use when a TLS connection is dialed.
-// Has no effect when not dialing a TLS connection.
-func DialTLSConfig(c *tls.Config) DialOption {
-	return DialOption{func(do *dialOptions) {
-		do.tlsConfig = c
-	}}
-}
-
-// DialTLSSkipVerify disables server name verification when connecting over
-// TLS. Has no effect when not dialing a TLS connection.
-func DialTLSSkipVerify(skip bool) DialOption {
-	return DialOption{func(do *dialOptions) {
-		do.skipVerify = skip
-	}}
-}
-
-// DialUseTLS specifies whether TLS should be used when connecting to the
-// server. This option is ignore by DialURL.
-func DialUseTLS(useTLS bool) DialOption {
-	return DialOption{func(do *dialOptions) {
-		do.useTLS = useTLS
-	}}
-}
-
-// Dial connects to the Redis server at the given network and
-// address using the specified options.
-func Dial(network, address string, options ...DialOption) (Conn, error) {
-	do := dialOptions{
-		dialer: &net.Dialer{
-			KeepAlive: time.Minute * 5,
-		},
-	}
-	for _, option := range options {
-		option.f(&do)
-	}
-	if do.dial == nil {
-		do.dial = do.dialer.Dial
-	}
-
-	netConn, err := do.dial(network, address)
-	if err != nil {
-		return nil, err
-	}
-
-	if do.useTLS {
-		var tlsConfig *tls.Config
-		if do.tlsConfig == nil {
-			tlsConfig = &tls.Config{InsecureSkipVerify: do.skipVerify}
-		} else {
-			tlsConfig = cloneTLSConfig(do.tlsConfig)
-		}
-		if tlsConfig.ServerName == "" {
-			host, _, err := net.SplitHostPort(address)
-			if err != nil {
-				netConn.Close()
-				return nil, err
-			}
-			tlsConfig.ServerName = host
-		}
-
-		tlsConn := tls.Client(netConn, tlsConfig)
-		if err := tlsConn.Handshake(); err != nil {
-			netConn.Close()
-			return nil, err
-		}
-		netConn = tlsConn
-	}
-
-	c := &conn{
-		conn:         netConn,
-		bw:           bufio.NewWriter(netConn),
-		br:           bufio.NewReader(netConn),
-		readTimeout:  do.readTimeout,
-		writeTimeout: do.writeTimeout,
-	}
-
-	if do.password != "" {
-		if _, err := c.Do("AUTH", do.password); err != nil {
-			netConn.Close()
-			return nil, err
-		}
-	}
-
-	if do.db != 0 {
-		if _, err := c.Do("SELECT", do.db); err != nil {
-			netConn.Close()
-			return nil, err
-		}
-	}
-
-	return c, nil
-}
-
-var pathDBRegexp = regexp.MustCompile(`/(\d*)\z`)
-
-// DialURL connects to a Redis server at the given URL using the Redis
-// URI scheme. URLs should follow the draft IANA specification for the
-// scheme (https://www.iana.org/assignments/uri-schemes/prov/redis).
-func DialURL(rawurl string, options ...DialOption) (Conn, error) {
-	u, err := url.Parse(rawurl)
-	if err != nil {
-		return nil, err
-	}
-
-	if u.Scheme != "redis" && u.Scheme != "rediss" {
-		return nil, fmt.Errorf("invalid redis URL scheme: %s", u.Scheme)
-	}
-
-	// As per the IANA draft spec, the host defaults to localhost and
-	// the port defaults to 6379.
-	host, port, err := net.SplitHostPort(u.Host)
-	if err != nil {
-		// assume port is missing
-		host = u.Host
-		port = "6379"
-	}
-	if host == "" {
-		host = "localhost"
-	}
-	address := net.JoinHostPort(host, port)
-
-	if u.User != nil {
-		password, isSet := u.User.Password()
-		if isSet {
-			options = append(options, DialPassword(password))
-		}
-	}
-
-	match := pathDBRegexp.FindStringSubmatch(u.Path)
-	if len(match) == 2 {
-		db := 0
-		if len(match[1]) > 0 {
-			db, err = strconv.Atoi(match[1])
-			if err != nil {
-				return nil, fmt.Errorf("invalid database: %s", u.Path[1:])
-			}
-		}
-		if db != 0 {
-			options = append(options, DialDatabase(db))
-		}
-	} else if u.Path != "" {
-		return nil, fmt.Errorf("invalid database: %s", u.Path[1:])
-	}
-
-	options = append(options, DialUseTLS(u.Scheme == "rediss"))
-
-	return Dial("tcp", address, options...)
-}
-
-// NewConn returns a new Redigo connection for the given net connection.
-func NewConn(netConn net.Conn, readTimeout, writeTimeout time.Duration) Conn {
-	return &conn{
-		conn:         netConn,
-		bw:           bufio.NewWriter(netConn),
-		br:           bufio.NewReader(netConn),
-		readTimeout:  readTimeout,
-		writeTimeout: writeTimeout,
-	}
-}
-
-func (c *conn) Close() error {
-	c.mu.Lock()
-	err := c.err
-	if c.err == nil {
-		c.err = errors.New("redigo: closed")
-		err = c.conn.Close()
-	}
-	c.mu.Unlock()
-	return err
-}
-
-func (c *conn) fatal(err error) error {
-	c.mu.Lock()
-	if c.err == nil {
-		c.err = err
-		// Close connection to force errors on subsequent calls and to unblock
-		// other reader or writer.
-		c.conn.Close()
-	}
-	c.mu.Unlock()
-	return err
-}
-
-func (c *conn) Err() error {
-	c.mu.Lock()
-	err := c.err
-	c.mu.Unlock()
-	return err
-}
-
-func (c *conn) writeLen(prefix byte, n int) error {
-	c.lenScratch[len(c.lenScratch)-1] = '\n'
-	c.lenScratch[len(c.lenScratch)-2] = '\r'
-	i := len(c.lenScratch) - 3
-	for {
-		c.lenScratch[i] = byte('0' + n%10)
-		i -= 1
-		n = n / 10
-		if n == 0 {
-			break
-		}
-	}
-	c.lenScratch[i] = prefix
-	_, err := c.bw.Write(c.lenScratch[i:])
-	return err
-}
-
-func (c *conn) writeString(s string) error {
-	c.writeLen('$', len(s))
-	c.bw.WriteString(s)
-	_, err := c.bw.WriteString("\r\n")
-	return err
-}
-
-func (c *conn) writeBytes(p []byte) error {
-	c.writeLen('$', len(p))
-	c.bw.Write(p)
-	_, err := c.bw.WriteString("\r\n")
-	return err
-}
-
-func (c *conn) writeInt64(n int64) error {
-	return c.writeBytes(strconv.AppendInt(c.numScratch[:0], n, 10))
-}
-
-func (c *conn) writeFloat64(n float64) error {
-	return c.writeBytes(strconv.AppendFloat(c.numScratch[:0], n, 'g', -1, 64))
-}
-
-func (c *conn) writeCommand(cmd string, args []interface{}) error {
-	c.writeLen('*', 1+len(args))
-	if err := c.writeString(cmd); err != nil {
-		return err
-	}
-	for _, arg := range args {
-		if err := c.writeArg(arg, true); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (c *conn) writeArg(arg interface{}, argumentTypeOK bool) (err error) {
-	switch arg := arg.(type) {
-	case string:
-		return c.writeString(arg)
-	case []byte:
-		return c.writeBytes(arg)
-	case int:
-		return c.writeInt64(int64(arg))
-	case int64:
-		return c.writeInt64(arg)
-	case float64:
-		return c.writeFloat64(arg)
-	case bool:
-		if arg {
-			return c.writeString("1")
-		} else {
-			return c.writeString("0")
-		}
-	case nil:
-		return c.writeString("")
-	case Argument:
-		if argumentTypeOK {
-			return c.writeArg(arg.RedisArg(), false)
-		}
-		// See comment in default clause below.
-		var buf bytes.Buffer
-		fmt.Fprint(&buf, arg)
-		return c.writeBytes(buf.Bytes())
-	default:
-		// This default clause is intended to handle builtin numeric types.
-		// The function should return an error for other types, but this is not
-		// done for compatibility with previous versions of the package.
-		var buf bytes.Buffer
-		fmt.Fprint(&buf, arg)
-		return c.writeBytes(buf.Bytes())
-	}
-}
-
-type protocolError string
-
-func (pe protocolError) Error() string {
-	return fmt.Sprintf("redigo: %s (possible server error or unsupported concurrent read by application)", string(pe))
-}
-
-func (c *conn) readLine() ([]byte, error) {
-	p, err := c.br.ReadSlice('\n')
-	if err == bufio.ErrBufferFull {
-		return nil, protocolError("long response line")
-	}
-	if err != nil {
-		return nil, err
-	}
-	i := len(p) - 2
-	if i < 0 || p[i] != '\r' {
-		return nil, protocolError("bad response line terminator")
-	}
-	return p[:i], nil
-}
-
-// parseLen parses bulk string and array lengths.
-func parseLen(p []byte) (int, error) {
-	if len(p) == 0 {
-		return -1, protocolError("malformed length")
-	}
-
-	if p[0] == '-' && len(p) == 2 && p[1] == '1' {
-		// handle $-1 and $-1 null replies.
-		return -1, nil
-	}
-
-	var n int
-	for _, b := range p {
-		n *= 10
-		if b < '0' || b > '9' {
-			return -1, protocolError("illegal bytes in length")
-		}
-		n += int(b - '0')
-	}
-
-	return n, nil
-}
-
-// parseInt parses an integer reply.
-func parseInt(p []byte) (interface{}, error) {
-	if len(p) == 0 {
-		return 0, protocolError("malformed integer")
-	}
-
-	var negate bool
-	if p[0] == '-' {
-		negate = true
-		p = p[1:]
-		if len(p) == 0 {
-			return 0, protocolError("malformed integer")
-		}
-	}
-
-	var n int64
-	for _, b := range p {
-		n *= 10
-		if b < '0' || b > '9' {
-			return 0, protocolError("illegal bytes in length")
-		}
-		n += int64(b - '0')
-	}
-
-	if negate {
-		n = -n
-	}
-	return n, nil
-}
-
-var (
-	okReply   interface{} = "OK"
-	pongReply interface{} = "PONG"
-)
-
-func (c *conn) readReply() (interface{}, error) {
-	line, err := c.readLine()
-	if err != nil {
-		return nil, err
-	}
-	if len(line) == 0 {
-		return nil, protocolError("short response line")
-	}
-	switch line[0] {
-	case '+':
-		switch {
-		case len(line) == 3 && line[1] == 'O' && line[2] == 'K':
-			// Avoid allocation for frequent "+OK" response.
-			return okReply, nil
-		case len(line) == 5 && line[1] == 'P' && line[2] == 'O' && line[3] == 'N' && line[4] == 'G':
-			// Avoid allocation in PING command benchmarks :)
-			return pongReply, nil
-		default:
-			return string(line[1:]), nil
-		}
-	case '-':
-		return Error(string(line[1:])), nil
-	case ':':
-		return parseInt(line[1:])
-	case '$':
-		n, err := parseLen(line[1:])
-		if n < 0 || err != nil {
-			return nil, err
-		}
-		p := make([]byte, n)
-		_, err = io.ReadFull(c.br, p)
-		if err != nil {
-			return nil, err
-		}
-		if line, err := c.readLine(); err != nil {
-			return nil, err
-		} else if len(line) != 0 {
-			return nil, protocolError("bad bulk string format")
-		}
-		return p, nil
-	case '*':
-		n, err := parseLen(line[1:])
-		if n < 0 || err != nil {
-			return nil, err
-		}
-		r := make([]interface{}, n)
-		for i := range r {
-			r[i], err = c.readReply()
-			if err != nil {
-				return nil, err
-			}
-		}
-		return r, nil
-	}
-	return nil, protocolError("unexpected response line")
-}
-
-func (c *conn) Send(cmd string, args ...interface{}) error {
-	c.mu.Lock()
-	c.pending += 1
-	c.mu.Unlock()
-	if c.writeTimeout != 0 {
-		c.conn.SetWriteDeadline(time.Now().Add(c.writeTimeout))
-	}
-	if err := c.writeCommand(cmd, args); err != nil {
-		return c.fatal(err)
-	}
-	return nil
-}
-
-func (c *conn) Flush() error {
-	if c.writeTimeout != 0 {
-		c.conn.SetWriteDeadline(time.Now().Add(c.writeTimeout))
-	}
-	if err := c.bw.Flush(); err != nil {
-		return c.fatal(err)
-	}
-	return nil
-}
-
-func (c *conn) Receive() (interface{}, error) {
-	return c.ReceiveWithTimeout(c.readTimeout)
-}
-
-func (c *conn) ReceiveWithTimeout(timeout time.Duration) (reply interface{}, err error) {
-	var deadline time.Time
-	if timeout != 0 {
-		deadline = time.Now().Add(timeout)
-	}
-	c.conn.SetReadDeadline(deadline)
-
-	if reply, err = c.readReply(); err != nil {
-		return nil, c.fatal(err)
-	}
-	// When using pub/sub, the number of receives can be greater than the
-	// number of sends. To enable normal use of the connection after
-	// unsubscribing from all channels, we do not decrement pending to a
-	// negative value.
-	//
-	// The pending field is decremented after the reply is read to handle the
-	// case where Receive is called before Send.
-	c.mu.Lock()
-	if c.pending > 0 {
-		c.pending -= 1
-	}
-	c.mu.Unlock()
-	if err, ok := reply.(Error); ok {
-		return nil, err
-	}
-	return
-}
-
-func (c *conn) Do(cmd string, args ...interface{}) (interface{}, error) {
-	return c.DoWithTimeout(c.readTimeout, cmd, args...)
-}
-
-func (c *conn) DoWithTimeout(readTimeout time.Duration, cmd string, args ...interface{}) (interface{}, error) {
-	c.mu.Lock()
-	pending := c.pending
-	c.pending = 0
-	c.mu.Unlock()
-
-	if cmd == "" && pending == 0 {
-		return nil, nil
-	}
-
-	if c.writeTimeout != 0 {
-		c.conn.SetWriteDeadline(time.Now().Add(c.writeTimeout))
-	}
-
-	if cmd != "" {
-		if err := c.writeCommand(cmd, args); err != nil {
-			return nil, c.fatal(err)
-		}
-	}
-
-	if err := c.bw.Flush(); err != nil {
-		return nil, c.fatal(err)
-	}
-
-	var deadline time.Time
-	if readTimeout != 0 {
-		deadline = time.Now().Add(readTimeout)
-	}
-	c.conn.SetReadDeadline(deadline)
-
-	if cmd == "" {
-		reply := make([]interface{}, pending)
-		for i := range reply {
-			r, e := c.readReply()
-			if e != nil {
-				return nil, c.fatal(e)
-			}
-			reply[i] = r
-		}
-		return reply, nil
-	}
-
-	var err error
-	var reply interface{}
-	for i := 0; i <= pending; i++ {
-		var e error
-		if reply, e = c.readReply(); e != nil {
-			return nil, c.fatal(e)
-		}
-		if e, ok := reply.(Error); ok && err == nil {
-			err = e
-		}
-	}
-	return reply, err
-}

vendor/github.com/garyburd/redigo/redis/doc.go

@@ -1,177 +0,0 @@
-// Copyright 2012 Gary Burd
-//
-// 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 redis is a client for the Redis database.
-//
-// The Redigo FAQ (https://github.com/garyburd/redigo/wiki/FAQ) contains more
-// documentation about this package.
-//
-// Connections
-//
-// The Conn interface is the primary interface for working with Redis.
-// Applications create connections by calling the Dial, DialWithTimeout or
-// NewConn functions. In the future, functions will be added for creating
-// sharded and other types of connections.
-//
-// The application must call the connection Close method when the application
-// is done with the connection.
-//
-// Executing Commands
-//
-// The Conn interface has a generic method for executing Redis commands:
-//
-//  Do(commandName string, args ...interface{}) (reply interface{}, err error)
-//
-// The Redis command reference (http://redis.io/commands) lists the available
-// commands. An example of using the Redis APPEND command is:
-//
-//  n, err := conn.Do("APPEND", "key", "value")
-//
-// The Do method converts command arguments to bulk strings for transmission
-// to the server as follows:
-//
-//  Go Type                 Conversion
-//  []byte                  Sent as is
-//  string                  Sent as is
-//  int, int64              strconv.FormatInt(v)
-//  float64                 strconv.FormatFloat(v, 'g', -1, 64)
-//  bool                    true -> "1", false -> "0"
-//  nil                     ""
-//  all other types         fmt.Fprint(w, v)
-//
-// Redis command reply types are represented using the following Go types:
-//
-//  Redis type              Go type
-//  error                   redis.Error
-//  integer                 int64
-//  simple string           string
-//  bulk string             []byte or nil if value not present.
-//  array                   []interface{} or nil if value not present.
-//
-// Use type assertions or the reply helper functions to convert from
-// interface{} to the specific Go type for the command result.
-//
-// Pipelining
-//
-// Connections support pipelining using the Send, Flush and Receive methods.
-//
-//  Send(commandName string, args ...interface{}) error
-//  Flush() error
-//  Receive() (reply interface{}, err error)
-//
-// Send writes the command to the connection's output buffer. Flush flushes the
-// connection's output buffer to the server. Receive reads a single reply from
-// the server. The following example shows a simple pipeline.
-//
-//  c.Send("SET", "foo", "bar")
-//  c.Send("GET", "foo")
-//  c.Flush()
-//  c.Receive() // reply from SET
-//  v, err = c.Receive() // reply from GET
-//
-// The Do method combines the functionality of the Send, Flush and Receive
-// methods. The Do method starts by writing the command and flushing the output
-// buffer. Next, the Do method receives all pending replies including the reply
-// for the command just sent by Do. If any of the received replies is an error,
-// then Do returns the error. If there are no errors, then Do returns the last
-// reply. If the command argument to the Do method is "", then the Do method
-// will flush the output buffer and receive pending replies without sending a
-// command.
-//
-// Use the Send and Do methods to implement pipelined transactions.
-//
-//  c.Send("MULTI")
-//  c.Send("INCR", "foo")
-//  c.Send("INCR", "bar")
-//  r, err := c.Do("EXEC")
-//  fmt.Println(r) // prints [1, 1]
-//
-// Concurrency
-//
-// Connections support one concurrent caller to the Receive method and one
-// concurrent caller to the Send and Flush methods. No other concurrency is
-// supported including concurrent calls to the Do method.
-//
-// For full concurrent access to Redis, use the thread-safe Pool to get, use
-// and release a connection from within a goroutine. Connections returned from
-// a Pool have the concurrency restrictions described in the previous
-// paragraph.
-//
-// Publish and Subscribe
-//
-// Use the Send, Flush and Receive methods to implement Pub/Sub subscribers.
-//
-//  c.Send("SUBSCRIBE", "example")
-//  c.Flush()
-//  for {
-//      reply, err := c.Receive()
-//      if err != nil {
-//          return err
-//      }
-//      // process pushed message
-//  }
-//
-// The PubSubConn type wraps a Conn with convenience methods for implementing
-// subscribers. The Subscribe, PSubscribe, Unsubscribe and PUnsubscribe methods
-// send and flush a subscription management command. The receive method
-// converts a pushed message to convenient types for use in a type switch.
-//
-//  psc := redis.PubSubConn{Conn: c}
-//  psc.Subscribe("example")
-//  for {
-//      switch v := psc.Receive().(type) {
-//      case redis.Message:
-//          fmt.Printf("%s: message: %s\n", v.Channel, v.Data)
-//      case redis.Subscription:
-//          fmt.Printf("%s: %s %d\n", v.Channel, v.Kind, v.Count)
-//      case error:
-//          return v
-//      }
-//  }
-//
-// Reply Helpers
-//
-// The Bool, Int, Bytes, String, Strings and Values functions convert a reply
-// to a value of a specific type. To allow convenient wrapping of calls to the
-// connection Do and Receive methods, the functions take a second argument of
-// type error.  If the error is non-nil, then the helper function returns the
-// error. If the error is nil, the function converts the reply to the specified
-// type:
-//
-//  exists, err := redis.Bool(c.Do("EXISTS", "foo"))
-//  if err != nil {
-//      // handle error return from c.Do or type conversion error.
-//  }
-//
-// The Scan function converts elements of a array reply to Go types:
-//
-//  var value1 int
-//  var value2 string
-//  reply, err := redis.Values(c.Do("MGET", "key1", "key2"))
-//  if err != nil {
-//      // handle error
-//  }
-//   if _, err := redis.Scan(reply, &value1, &value2); err != nil {
-//      // handle error
-//  }
-//
-// Errors
-//
-// Connection methods return error replies from the server as type redis.Error.
-//
-// Call the connection Err() method to determine if the connection encountered
-// non-recoverable error such as a network error or protocol parsing error. If
-// Err() returns a non-nil value, then the connection is not usable and should
-// be closed.
-package redis // import "github.com/garyburd/redigo/redis"

vendor/github.com/garyburd/redigo/redis/go16.go

@@ -1,27 +0,0 @@
-// +build !go1.7
-
-package redis
-
-import "crypto/tls"
-
-func cloneTLSConfig(cfg *tls.Config) *tls.Config {
-	return &tls.Config{
-		Rand:                     cfg.Rand,
-		Time:                     cfg.Time,
-		Certificates:             cfg.Certificates,
-		NameToCertificate:        cfg.NameToCertificate,
-		GetCertificate:           cfg.GetCertificate,
-		RootCAs:                  cfg.RootCAs,
-		NextProtos:               cfg.NextProtos,
-		ServerName:               cfg.ServerName,
-		ClientAuth:               cfg.ClientAuth,
-		ClientCAs:                cfg.ClientCAs,
-		InsecureSkipVerify:       cfg.InsecureSkipVerify,
-		CipherSuites:             cfg.CipherSuites,
-		PreferServerCipherSuites: cfg.PreferServerCipherSuites,
-		ClientSessionCache:       cfg.ClientSessionCache,
-		MinVersion:               cfg.MinVersion,
-		MaxVersion:               cfg.MaxVersion,
-		CurvePreferences:         cfg.CurvePreferences,
-	}
-}

vendor/github.com/garyburd/redigo/redis/go17.go

@@ -1,29 +0,0 @@
-// +build go1.7,!go1.8
-
-package redis
-
-import "crypto/tls"
-
-func cloneTLSConfig(cfg *tls.Config) *tls.Config {
-	return &tls.Config{
-		Rand:                        cfg.Rand,
-		Time:                        cfg.Time,
-		Certificates:                cfg.Certificates,
-		NameToCertificate:           cfg.NameToCertificate,
-		GetCertificate:              cfg.GetCertificate,
-		RootCAs:                     cfg.RootCAs,
-		NextProtos:                  cfg.NextProtos,
-		ServerName:                  cfg.ServerName,
-		ClientAuth:                  cfg.ClientAuth,
-		ClientCAs:                   cfg.ClientCAs,
-		InsecureSkipVerify:          cfg.InsecureSkipVerify,
-		CipherSuites:                cfg.CipherSuites,
-		PreferServerCipherSuites:    cfg.PreferServerCipherSuites,
-		ClientSessionCache:          cfg.ClientSessionCache,
-		MinVersion:                  cfg.MinVersion,
-		MaxVersion:                  cfg.MaxVersion,
-		CurvePreferences:            cfg.CurvePreferences,
-		DynamicRecordSizingDisabled: cfg.DynamicRecordSizingDisabled,
-		Renegotiation:               cfg.Renegotiation,
-	}
-}

vendor/github.com/garyburd/redigo/redis/go18.go

@@ -1,9 +0,0 @@
-// +build go1.8
-
-package redis
-
-import "crypto/tls"
-
-func cloneTLSConfig(cfg *tls.Config) *tls.Config {
-	return cfg.Clone()
-}

vendor/github.com/garyburd/redigo/redis/log.go

@@ -1,134 +0,0 @@
-// Copyright 2012 Gary Burd
-//
-// 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 redis
-
-import (
-	"bytes"
-	"fmt"
-	"log"
-	"time"
-)
-
-var (
-	_ ConnWithTimeout = (*loggingConn)(nil)
-)
-
-// NewLoggingConn returns a logging wrapper around a connection.
-func NewLoggingConn(conn Conn, logger *log.Logger, prefix string) Conn {
-	if prefix != "" {
-		prefix = prefix + "."
-	}
-	return &loggingConn{conn, logger, prefix}
-}
-
-type loggingConn struct {
-	Conn
-	logger *log.Logger
-	prefix string
-}
-
-func (c *loggingConn) Close() error {
-	err := c.Conn.Close()
-	var buf bytes.Buffer
-	fmt.Fprintf(&buf, "%sClose() -> (%v)", c.prefix, err)
-	c.logger.Output(2, buf.String())
-	return err
-}
-
-func (c *loggingConn) printValue(buf *bytes.Buffer, v interface{}) {
-	const chop = 32
-	switch v := v.(type) {
-	case []byte:
-		if len(v) > chop {
-			fmt.Fprintf(buf, "%q...", v[:chop])
-		} else {
-			fmt.Fprintf(buf, "%q", v)
-		}
-	case string:
-		if len(v) > chop {
-			fmt.Fprintf(buf, "%q...", v[:chop])
-		} else {
-			fmt.Fprintf(buf, "%q", v)
-		}
-	case []interface{}:
-		if len(v) == 0 {
-			buf.WriteString("[]")
-		} else {
-			sep := "["
-			fin := "]"
-			if len(v) > chop {
-				v = v[:chop]
-				fin = "...]"
-			}
-			for _, vv := range v {
-				buf.WriteString(sep)
-				c.printValue(buf, vv)
-				sep = ", "
-			}
-			buf.WriteString(fin)
-		}
-	default:
-		fmt.Fprint(buf, v)
-	}
-}
-
-func (c *loggingConn) print(method, commandName string, args []interface{}, reply interface{}, err error) {
-	var buf bytes.Buffer
-	fmt.Fprintf(&buf, "%s%s(", c.prefix, method)
-	if method != "Receive" {
-		buf.WriteString(commandName)
-		for _, arg := range args {
-			buf.WriteString(", ")
-			c.printValue(&buf, arg)
-		}
-	}
-	buf.WriteString(") -> (")
-	if method != "Send" {
-		c.printValue(&buf, reply)
-		buf.WriteString(", ")
-	}
-	fmt.Fprintf(&buf, "%v)", err)
-	c.logger.Output(3, buf.String())
-}
-
-func (c *loggingConn) Do(commandName string, args ...interface{}) (interface{}, error) {
-	reply, err := c.Conn.Do(commandName, args...)
-	c.print("Do", commandName, args, reply, err)
-	return reply, err
-}
-
-func (c *loggingConn) DoWithTimeout(timeout time.Duration, commandName string, args ...interface{}) (interface{}, error) {
-	reply, err := DoWithTimeout(c.Conn, timeout, commandName, args...)
-	c.print("DoWithTimeout", commandName, args, reply, err)
-	return reply, err
-}
-
-func (c *loggingConn) Send(commandName string, args ...interface{}) error {
-	err := c.Conn.Send(commandName, args...)
-	c.print("Send", commandName, args, nil, err)
-	return err
-}
-
-func (c *loggingConn) Receive() (interface{}, error) {
-	reply, err := c.Conn.Receive()
-	c.print("Receive", "", nil, reply, err)
-	return reply, err
-}
-
-func (c *loggingConn) ReceiveWithTimeout(timeout time.Duration) (interface{}, error) {
-	reply, err := ReceiveWithTimeout(c.Conn, timeout)
-	c.print("ReceiveWithTimeout", "", nil, reply, err)
-	return reply, err
-}

vendor/github.com/garyburd/redigo/redis/pool.go

@@ -1,527 +0,0 @@
-// Copyright 2012 Gary Burd
-//
-// 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 redis
-
-import (
-	"bytes"
-	"crypto/rand"
-	"crypto/sha1"
-	"errors"
-	"io"
-	"strconv"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"github.com/garyburd/redigo/internal"
-)
-
-var (
-	_ ConnWithTimeout = (*pooledConnection)(nil)
-	_ ConnWithTimeout = (*errorConnection)(nil)
-)
-
-var nowFunc = time.Now // for testing
-
-// ErrPoolExhausted is returned from a pool connection method (Do, Send,
-// Receive, Flush, Err) when the maximum number of database connections in the
-// pool has been reached.
-var ErrPoolExhausted = errors.New("redigo: connection pool exhausted")
-
-var (
-	errPoolClosed = errors.New("redigo: connection pool closed")
-	errConnClosed = errors.New("redigo: connection closed")
-)
-
-// Pool maintains a pool of connections. The application calls the Get method
-// to get a connection from the pool and the connection's Close method to
-// return the connection's resources to the pool.
-//
-// The following example shows how to use a pool in a web application. The
-// application creates a pool at application startup and makes it available to
-// request handlers using a package level variable. The pool configuration used
-// here is an example, not a recommendation.
-//
-//  func newPool(addr string) *redis.Pool {
-//    return &redis.Pool{
-//      MaxIdle: 3,
-//      IdleTimeout: 240 * time.Second,
-//      Dial: func () (redis.Conn, error) { return redis.Dial("tcp", addr) },
-//    }
-//  }
-//
-//  var (
-//    pool *redis.Pool
-//    redisServer = flag.String("redisServer", ":6379", "")
-//  )
-//
-//  func main() {
-//    flag.Parse()
-//    pool = newPool(*redisServer)
-//    ...
-//  }
-//
-// A request handler gets a connection from the pool and closes the connection
-// when the handler is done:
-//
-//  func serveHome(w http.ResponseWriter, r *http.Request) {
-//      conn := pool.Get()
-//      defer conn.Close()
-//      ...
-//  }
-//
-// Use the Dial function to authenticate connections with the AUTH command or
-// select a database with the SELECT command:
-//
-//  pool := &redis.Pool{
-//    // Other pool configuration not shown in this example.
-//    Dial: func () (redis.Conn, error) {
-//      c, err := redis.Dial("tcp", server)
-//      if err != nil {
-//        return nil, err
-//      }
-//      if _, err := c.Do("AUTH", password); err != nil {
-//        c.Close()
-//        return nil, err
-//      }
-//      if _, err := c.Do("SELECT", db); err != nil {
-//        c.Close()
-//        return nil, err
-//      }
-//      return c, nil
-//    },
-//  }
-//
-// Use the TestOnBorrow function to check the health of an idle connection
-// before the connection is returned to the application. This example PINGs
-// connections that have been idle more than a minute:
-//
-//  pool := &redis.Pool{
-//    // Other pool configuration not shown in this example.
-//    TestOnBorrow: func(c redis.Conn, t time.Time) error {
-//      if time.Since(t) < time.Minute {
-//        return nil
-//      }
-//      _, err := c.Do("PING")
-//      return err
-//    },
-//  }
-//
-type Pool struct {
-	// Dial is an application supplied function for creating and configuring a
-	// connection.
-	//
-	// The connection returned from Dial must not be in a special state
-	// (subscribed to pubsub channel, transaction started, ...).
-	Dial func() (Conn, error)
-
-	// TestOnBorrow is an optional application supplied function for checking
-	// the health of an idle connection before the connection is used again by
-	// the application. Argument t is the time that the connection was returned
-	// to the pool. If the function returns an error, then the connection is
-	// closed.
-	TestOnBorrow func(c Conn, t time.Time) error
-
-	// Maximum number of idle connections in the pool.
-	MaxIdle int
-
-	// Maximum number of connections allocated by the pool at a given time.
-	// When zero, there is no limit on the number of connections in the pool.
-	MaxActive int
-
-	// Close connections after remaining idle for this duration. If the value
-	// is zero, then idle connections are not closed. Applications should set
-	// the timeout to a value less than the server's timeout.
-	IdleTimeout time.Duration
-
-	// If Wait is true and the pool is at the MaxActive limit, then Get() waits
-	// for a connection to be returned to the pool before returning.
-	Wait bool
-
-	chInitialized uint32 // set to 1 when field ch is initialized
-
-	mu     sync.Mutex    // mu protects the following fields
-	closed bool          // set to true when the pool is closed.
-	active int           // the number of open connections in the pool
-	ch     chan struct{} // limits open connections when p.Wait is true
-	idle   idleList      // idle connections
-}
-
-// NewPool creates a new pool.
-//
-// Deprecated: Initialize the Pool directory as shown in the example.
-func NewPool(newFn func() (Conn, error), maxIdle int) *Pool {
-	return &Pool{Dial: newFn, MaxIdle: maxIdle}
-}
-
-// Get gets a connection. The application must close the returned connection.
-// This method always returns a valid connection so that applications can defer
-// error handling to the first use of the connection. If there is an error
-// getting an underlying connection, then the connection Err, Do, Send, Flush
-// and Receive methods return that error.
-func (p *Pool) Get() Conn {
-	c, err := p.get(nil)
-	if err != nil {
-		return errorConnection{err}
-	}
-	return &pooledConnection{p: p, c: c}
-}
-
-// PoolStats contains pool statistics.
-type PoolStats struct {
-	// ActiveCount is the number of connections in the pool. The count includes
-	// idle connections and connections in use.
-	ActiveCount int
-	// IdleCount is the number of idle connections in the pool.
-	IdleCount int
-}
-
-// Stats returns pool's statistics.
-func (p *Pool) Stats() PoolStats {
-	p.mu.Lock()
-	stats := PoolStats{
-		ActiveCount: p.active,
-		IdleCount:   p.idle.count,
-	}
-	p.mu.Unlock()
-
-	return stats
-}
-
-// ActiveCount returns the number of connections in the pool. The count
-// includes idle connections and connections in use.
-func (p *Pool) ActiveCount() int {
-	p.mu.Lock()
-	active := p.active
-	p.mu.Unlock()
-	return active
-}
-
-// IdleCount returns the number of idle connections in the pool.
-func (p *Pool) IdleCount() int {
-	p.mu.Lock()
-	idle := p.idle.count
-	p.mu.Unlock()
-	return idle
-}
-
-// Close releases the resources used by the pool.
-func (p *Pool) Close() error {
-	p.mu.Lock()
-	if p.closed {
-		p.mu.Unlock()
-		return nil
-	}
-	p.closed = true
-	p.active -= p.idle.count
-	ic := p.idle.front
-	p.idle.count = 0
-	p.idle.front, p.idle.back = nil, nil
-	if p.ch != nil {
-		close(p.ch)
-	}
-	p.mu.Unlock()
-	for ; ic != nil; ic = ic.next {
-		ic.c.Close()
-	}
-	return nil
-}
-
-func (p *Pool) lazyInit() {
-	// Fast path.
-	if atomic.LoadUint32(&p.chInitialized) == 1 {
-		return
-	}
-	// Slow path.
-	p.mu.Lock()
-	if p.chInitialized == 0 {
-		p.ch = make(chan struct{}, p.MaxActive)
-		if p.closed {
-			close(p.ch)
-		} else {
-			for i := 0; i < p.MaxActive; i++ {
-				p.ch <- struct{}{}
-			}
-		}
-		atomic.StoreUint32(&p.chInitialized, 1)
-	}
-	p.mu.Unlock()
-}
-
-// get prunes stale connections and returns a connection from the idle list or
-// creates a new connection.
-func (p *Pool) get(ctx interface {
-	Done() <-chan struct{}
-	Err() error
-}) (Conn, error) {
-
-	// Handle limit for p.Wait == true.
-	if p.Wait && p.MaxActive > 0 {
-		p.lazyInit()
-		if ctx == nil {
-			<-p.ch
-		} else {
-			select {
-			case <-p.ch:
-			case <-ctx.Done():
-				return nil, ctx.Err()
-			}
-		}
-	}
-
-	p.mu.Lock()
-
-	// Prune stale connections at the back of the idle list.
-	if p.IdleTimeout > 0 {
-		n := p.idle.count
-		for i := 0; i < n && p.idle.back != nil && p.idle.back.t.Add(p.IdleTimeout).Before(nowFunc()); i++ {
-			c := p.idle.back.c
-			p.idle.popBack()
-			p.mu.Unlock()
-			c.Close()
-			p.mu.Lock()
-			p.active--
-		}
-	}
-
-	// Get idle connection from the front of idle list.
-	for p.idle.front != nil {
-		ic := p.idle.front
-		p.idle.popFront()
-		p.mu.Unlock()
-		if p.TestOnBorrow == nil || p.TestOnBorrow(ic.c, ic.t) == nil {
-			return ic.c, nil
-		}
-		ic.c.Close()
-		p.mu.Lock()
-		p.active--
-	}
-
-	// Check for pool closed before dialing a new connection.
-	if p.closed {
-		p.mu.Unlock()
-		return nil, errors.New("redigo: get on closed pool")
-	}
-
-	// Handle limit for p.Wait == false.
-	if !p.Wait && p.MaxActive > 0 && p.active >= p.MaxActive {
-		p.mu.Unlock()
-		return nil, ErrPoolExhausted
-	}
-
-	p.active++
-	p.mu.Unlock()
-	c, err := p.Dial()
-	if err != nil {
-		c = nil
-		p.mu.Lock()
-		p.active--
-		if p.ch != nil && !p.closed {
-			p.ch <- struct{}{}
-		}
-		p.mu.Unlock()
-	}
-	return c, err
-}
-
-func (p *Pool) put(c Conn, forceClose bool) error {
-	p.mu.Lock()
-	if !p.closed && !forceClose {
-		p.idle.pushFront(&idleConn{t: nowFunc(), c: c})
-		if p.idle.count > p.MaxIdle {
-			c = p.idle.back.c
-			p.idle.popBack()
-		} else {
-			c = nil
-		}
-	}
-
-	if c != nil {
-		p.mu.Unlock()
-		c.Close()
-		p.mu.Lock()
-		p.active--
-	}
-
-	if p.ch != nil && !p.closed {
-		p.ch <- struct{}{}
-	}
-	p.mu.Unlock()
-	return nil
-}
-
-type pooledConnection struct {
-	p     *Pool
-	c     Conn
-	state int
-}
-
-var (
-	sentinel     []byte
-	sentinelOnce sync.Once
-)
-
-func initSentinel() {
-	p := make([]byte, 64)
-	if _, err := rand.Read(p); err == nil {
-		sentinel = p
-	} else {
-		h := sha1.New()
-		io.WriteString(h, "Oops, rand failed. Use time instead.")
-		io.WriteString(h, strconv.FormatInt(time.Now().UnixNano(), 10))
-		sentinel = h.Sum(nil)
-	}
-}
-
-func (pc *pooledConnection) Close() error {
-	c := pc.c
-	if _, ok := c.(errorConnection); ok {
-		return nil
-	}
-	pc.c = errorConnection{errConnClosed}
-
-	if pc.state&internal.MultiState != 0 {
-		c.Send("DISCARD")
-		pc.state &^= (internal.MultiState | internal.WatchState)
-	} else if pc.state&internal.WatchState != 0 {
-		c.Send("UNWATCH")
-		pc.state &^= internal.WatchState
-	}
-	if pc.state&internal.SubscribeState != 0 {
-		c.Send("UNSUBSCRIBE")
-		c.Send("PUNSUBSCRIBE")
-		// To detect the end of the message stream, ask the server to echo
-		// a sentinel value and read until we see that value.
-		sentinelOnce.Do(initSentinel)
-		c.Send("ECHO", sentinel)
-		c.Flush()
-		for {
-			p, err := c.Receive()
-			if err != nil {
-				break
-			}
-			if p, ok := p.([]byte); ok && bytes.Equal(p, sentinel) {
-				pc.state &^= internal.SubscribeState
-				break
-			}
-		}
-	}
-	c.Do("")
-	pc.p.put(c, pc.state != 0 || c.Err() != nil)
-	return nil
-}
-
-func (pc *pooledConnection) Err() error {
-	return pc.c.Err()
-}
-
-func (pc *pooledConnection) Do(commandName string, args ...interface{}) (reply interface{}, err error) {
-	ci := internal.LookupCommandInfo(commandName)
-	pc.state = (pc.state | ci.Set) &^ ci.Clear
-	return pc.c.Do(commandName, args...)
-}
-
-func (pc *pooledConnection) DoWithTimeout(timeout time.Duration, commandName string, args ...interface{}) (reply interface{}, err error) {
-	cwt, ok := pc.c.(ConnWithTimeout)
-	if !ok {
-		return nil, errTimeoutNotSupported
-	}
-	ci := internal.LookupCommandInfo(commandName)
-	pc.state = (pc.state | ci.Set) &^ ci.Clear
-	return cwt.DoWithTimeout(timeout, commandName, args...)
-}
-
-func (pc *pooledConnection) Send(commandName string, args ...interface{}) error {
-	ci := internal.LookupCommandInfo(commandName)
-	pc.state = (pc.state | ci.Set) &^ ci.Clear
-	return pc.c.Send(commandName, args...)
-}
-
-func (pc *pooledConnection) Flush() error {
-	return pc.c.Flush()
-}
-
-func (pc *pooledConnection) Receive() (reply interface{}, err error) {
-	return pc.c.Receive()
-}
-
-func (pc *pooledConnection) ReceiveWithTimeout(timeout time.Duration) (reply interface{}, err error) {
-	cwt, ok := pc.c.(ConnWithTimeout)
-	if !ok {
-		return nil, errTimeoutNotSupported
-	}
-	return cwt.ReceiveWithTimeout(timeout)
-}
-
-type errorConnection struct{ err error }
-
-func (ec errorConnection) Do(string, ...interface{}) (interface{}, error) { return nil, ec.err }
-func (ec errorConnection) DoWithTimeout(time.Duration, string, ...interface{}) (interface{}, error) {
-	return nil, ec.err
-}
-func (ec errorConnection) Send(string, ...interface{}) error                     { return ec.err }
-func (ec errorConnection) Err() error                                            { return ec.err }
-func (ec errorConnection) Close() error                                          { return nil }
-func (ec errorConnection) Flush() error                                          { return ec.err }
-func (ec errorConnection) Receive() (interface{}, error)                         { return nil, ec.err }
-func (ec errorConnection) ReceiveWithTimeout(time.Duration) (interface{}, error) { return nil, ec.err }
-
-type idleList struct {
-	count       int
-	front, back *idleConn
-}
-
-type idleConn struct {
-	c          Conn
-	t          time.Time
-	next, prev *idleConn
-}
-
-func (l *idleList) pushFront(ic *idleConn) {
-	ic.next = l.front
-	ic.prev = nil
-	if l.count == 0 {
-		l.back = ic
-	} else {
-		l.front.prev = ic
-	}
-	l.front = ic
-	l.count++
-	return
-}
-
-func (l *idleList) popFront() {
-	ic := l.front
-	l.count--
-	if l.count == 0 {
-		l.front, l.back = nil, nil
-	} else {
-		ic.next.prev = nil
-		l.front = ic.next
-	}
-	ic.next, ic.prev = nil, nil
-}
-
-func (l *idleList) popBack() {
-	ic := l.back
-	l.count--
-	if l.count == 0 {
-		l.front, l.back = nil, nil
-	} else {
-		ic.prev.next = nil
-		l.back = ic.prev
-	}
-	ic.next, ic.prev = nil, nil
-}

vendor/github.com/garyburd/redigo/redis/pool17.go

@@ -1,35 +0,0 @@
-// Copyright 2018 Gary Burd
-//
-// 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.
-
-// +build go1.7
-
-package redis
-
-import "context"
-
-// GetContext gets a connection using the provided context.
-//
-// The provided Context must be non-nil. If the context expires before the
-// connection is complete, an error is returned. Any expiration on the context
-// will not affect the returned connection.
-//
-// If the function completes without error, then the application must close the
-// returned connection.
-func (p *Pool) GetContext(ctx context.Context) (Conn, error) {
-	c, err := p.get(ctx)
-	if err != nil {
-		return errorConnection{err}, err
-	}
-	return &pooledConnection{p: p, c: c}, nil
-}

vendor/github.com/garyburd/redigo/redis/pubsub.go

@@ -1,157 +0,0 @@
-// Copyright 2012 Gary Burd
-//
-// 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 redis
-
-import (
-	"errors"
-	"time"
-)
-
-// Subscription represents a subscribe or unsubscribe notification.
-type Subscription struct {
-	// Kind is "subscribe", "unsubscribe", "psubscribe" or "punsubscribe"
-	Kind string
-
-	// The channel that was changed.
-	Channel string
-
-	// The current number of subscriptions for connection.
-	Count int
-}
-
-// Message represents a message notification.
-type Message struct {
-	// The originating channel.
-	Channel string
-
-	// The message data.
-	Data []byte
-}
-
-// PMessage represents a pmessage notification.
-type PMessage struct {
-	// The matched pattern.
-	Pattern string
-
-	// The originating channel.
-	Channel string
-
-	// The message data.
-	Data []byte
-}
-
-// Pong represents a pubsub pong notification.
-type Pong struct {
-	Data string
-}
-
-// PubSubConn wraps a Conn with convenience methods for subscribers.
-type PubSubConn struct {
-	Conn Conn
-}
-
-// Close closes the connection.
-func (c PubSubConn) Close() error {
-	return c.Conn.Close()
-}
-
-// Subscribe subscribes the connection to the specified channels.
-func (c PubSubConn) Subscribe(channel ...interface{}) error {
-	c.Conn.Send("SUBSCRIBE", channel...)
-	return c.Conn.Flush()
-}
-
-// PSubscribe subscribes the connection to the given patterns.
-func (c PubSubConn) PSubscribe(channel ...interface{}) error {
-	c.Conn.Send("PSUBSCRIBE", channel...)
-	return c.Conn.Flush()
-}
-
-// Unsubscribe unsubscribes the connection from the given channels, or from all
-// of them if none is given.
-func (c PubSubConn) Unsubscribe(channel ...interface{}) error {
-	c.Conn.Send("UNSUBSCRIBE", channel...)
-	return c.Conn.Flush()
-}
-
-// PUnsubscribe unsubscribes the connection from the given patterns, or from all
-// of them if none is given.
-func (c PubSubConn) PUnsubscribe(channel ...interface{}) error {
-	c.Conn.Send("PUNSUBSCRIBE", channel...)
-	return c.Conn.Flush()
-}
-
-// Ping sends a PING to the server with the specified data.
-//
-// The connection must be subscribed to at least one channel or pattern when
-// calling this method.
-func (c PubSubConn) Ping(data string) error {
-	c.Conn.Send("PING", data)
-	return c.Conn.Flush()
-}
-
-// Receive returns a pushed message as a Subscription, Message, PMessage, Pong
-// or error. The return value is intended to be used directly in a type switch
-// as illustrated in the PubSubConn example.
-func (c PubSubConn) Receive() interface{} {
-	return c.receiveInternal(c.Conn.Receive())
-}
-
-// ReceiveWithTimeout is like Receive, but it allows the application to
-// override the connection's default timeout.
-func (c PubSubConn) ReceiveWithTimeout(timeout time.Duration) interface{} {
-	return c.receiveInternal(ReceiveWithTimeout(c.Conn, timeout))
-}
-
-func (c PubSubConn) receiveInternal(replyArg interface{}, errArg error) interface{} {
-	reply, err := Values(replyArg, errArg)
-	if err != nil {
-		return err
-	}
-
-	var kind string
-	reply, err = Scan(reply, &kind)
-	if err != nil {
-		return err
-	}
-
-	switch kind {
-	case "message":
-		var m Message
-		if _, err := Scan(reply, &m.Channel, &m.Data); err != nil {
-			return err
-		}
-		return m
-	case "pmessage":
-		var pm PMessage
-		if _, err := Scan(reply, &pm.Pattern, &pm.Channel, &pm.Data); err != nil {
-			return err
-		}
-		return pm
-	case "subscribe", "psubscribe", "unsubscribe", "punsubscribe":
-		s := Subscription{Kind: kind}
-		if _, err := Scan(reply, &s.Channel, &s.Count); err != nil {
-			return err
-		}
-		return s
-	case "pong":
-		var p Pong
-		if _, err := Scan(reply, &p.Data); err != nil {
-			return err
-		}
-		return p
-	}
-	return errors.New("redigo: unknown pubsub notification")
-}

vendor/github.com/garyburd/redigo/redis/redis.go

@@ -1,117 +0,0 @@
-// Copyright 2012 Gary Burd
-//
-// 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 redis
-
-import (
-	"errors"
-	"time"
-)
-
-// Error represents an error returned in a command reply.
-type Error string
-
-func (err Error) Error() string { return string(err) }
-
-// Conn represents a connection to a Redis server.
-type Conn interface {
-	// Close closes the connection.
-	Close() error
-
-	// Err returns a non-nil value when the connection is not usable.
-	Err() error
-
-	// Do sends a command to the server and returns the received reply.
-	Do(commandName string, args ...interface{}) (reply interface{}, err error)
-
-	// Send writes the command to the client's output buffer.
-	Send(commandName string, args ...interface{}) error
-
-	// Flush flushes the output buffer to the Redis server.
-	Flush() error
-
-	// Receive receives a single reply from the Redis server
-	Receive() (reply interface{}, err error)
-}
-
-// Argument is the interface implemented by an object which wants to control how
-// the object is converted to Redis bulk strings.
-type Argument interface {
-	// RedisArg returns a value to be encoded as a bulk string per the
-	// conversions listed in the section 'Executing Commands'.
-	// Implementations should typically return a []byte or string.
-	RedisArg() interface{}
-}
-
-// Scanner is implemented by an object which wants to control its value is
-// interpreted when read from Redis.
-type Scanner interface {
-	// RedisScan assigns a value from a Redis value. The argument src is one of
-	// the reply types listed in the section `Executing Commands`.
-	//
-	// An error should be returned if the value cannot be stored without
-	// loss of information.
-	RedisScan(src interface{}) error
-}
-
-// ConnWithTimeout is an optional interface that allows the caller to override
-// a connection's default read timeout. This interface is useful for executing
-// the BLPOP, BRPOP, BRPOPLPUSH, XREAD and other commands that block at the
-// server.
-//
-// A connection's default read timeout is set with the DialReadTimeout dial
-// option. Applications should rely on the default timeout for commands that do
-// not block at the server.
-//
-// All of the Conn implementations in this package satisfy the ConnWithTimeout
-// interface.
-//
-// Use the DoWithTimeout and ReceiveWithTimeout helper functions to simplify
-// use of this interface.
-type ConnWithTimeout interface {
-	Conn
-
-	// Do sends a command to the server and returns the received reply.
-	// The timeout overrides the read timeout set when dialing the
-	// connection.
-	DoWithTimeout(timeout time.Duration, commandName string, args ...interface{}) (reply interface{}, err error)
-
-	// Receive receives a single reply from the Redis server. The timeout
-	// overrides the read timeout set when dialing the connection.
-	ReceiveWithTimeout(timeout time.Duration) (reply interface{}, err error)
-}
-
-var errTimeoutNotSupported = errors.New("redis: connection does not support ConnWithTimeout")
-
-// DoWithTimeout executes a Redis command with the specified read timeout. If
-// the connection does not satisfy the ConnWithTimeout interface, then an error
-// is returned.
-func DoWithTimeout(c Conn, timeout time.Duration, cmd string, args ...interface{}) (interface{}, error) {
-	cwt, ok := c.(ConnWithTimeout)
-	if !ok {
-		return nil, errTimeoutNotSupported
-	}
-	return cwt.DoWithTimeout(timeout, cmd, args...)
-}
-
-// ReceiveWithTimeout receives a reply with the specified read timeout. If the
-// connection does not satisfy the ConnWithTimeout interface, then an error is
-// returned.
-func ReceiveWithTimeout(c Conn, timeout time.Duration) (interface{}, error) {
-	cwt, ok := c.(ConnWithTimeout)
-	if !ok {
-		return nil, errTimeoutNotSupported
-	}
-	return cwt.ReceiveWithTimeout(timeout)
-}

vendor/github.com/garyburd/redigo/redis/reply.go

@@ -1,479 +0,0 @@
-// Copyright 2012 Gary Burd
-//
-// 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 redis
-
-import (
-	"errors"
-	"fmt"
-	"strconv"
-)
-
-// ErrNil indicates that a reply value is nil.
-var ErrNil = errors.New("redigo: nil returned")
-
-// Int is a helper that converts a command reply to an integer. If err is not
-// equal to nil, then Int returns 0, err. Otherwise, Int converts the
-// reply to an int as follows:
-//
-//  Reply type    Result
-//  integer       int(reply), nil
-//  bulk string   parsed reply, nil
-//  nil           0, ErrNil
-//  other         0, error
-func Int(reply interface{}, err error) (int, error) {
-	if err != nil {
-		return 0, err
-	}
-	switch reply := reply.(type) {
-	case int64:
-		x := int(reply)
-		if int64(x) != reply {
-			return 0, strconv.ErrRange
-		}
-		return x, nil
-	case []byte:
-		n, err := strconv.ParseInt(string(reply), 10, 0)
-		return int(n), err
-	case nil:
-		return 0, ErrNil
-	case Error:
-		return 0, reply
-	}
-	return 0, fmt.Errorf("redigo: unexpected type for Int, got type %T", reply)
-}
-
-// Int64 is a helper that converts a command reply to 64 bit integer. If err is
-// not equal to nil, then Int returns 0, err. Otherwise, Int64 converts the
-// reply to an int64 as follows:
-//
-//  Reply type    Result
-//  integer       reply, nil
-//  bulk string   parsed reply, nil
-//  nil           0, ErrNil
-//  other         0, error
-func Int64(reply interface{}, err error) (int64, error) {
-	if err != nil {
-		return 0, err
-	}
-	switch reply := reply.(type) {
-	case int64:
-		return reply, nil
-	case []byte:
-		n, err := strconv.ParseInt(string(reply), 10, 64)
-		return n, err
-	case nil:
-		return 0, ErrNil
-	case Error:
-		return 0, reply
-	}
-	return 0, fmt.Errorf("redigo: unexpected type for Int64, got type %T", reply)
-}
-
-var errNegativeInt = errors.New("redigo: unexpected value for Uint64")
-
-// Uint64 is a helper that converts a command reply to 64 bit integer. If err is
-// not equal to nil, then Int returns 0, err. Otherwise, Int64 converts the
-// reply to an int64 as follows:
-//
-//  Reply type    Result
-//  integer       reply, nil
-//  bulk string   parsed reply, nil
-//  nil           0, ErrNil
-//  other         0, error
-func Uint64(reply interface{}, err error) (uint64, error) {
-	if err != nil {
-		return 0, err
-	}
-	switch reply := reply.(type) {
-	case int64:
-		if reply < 0 {
-			return 0, errNegativeInt
-		}
-		return uint64(reply), nil
-	case []byte:
-		n, err := strconv.ParseUint(string(reply), 10, 64)
-		return n, err
-	case nil:
-		return 0, ErrNil
-	case Error:
-		return 0, reply
-	}
-	return 0, fmt.Errorf("redigo: unexpected type for Uint64, got type %T", reply)
-}
-
-// Float64 is a helper that converts a command reply to 64 bit float. If err is
-// not equal to nil, then Float64 returns 0, err. Otherwise, Float64 converts
-// the reply to an int as follows:
-//
-//  Reply type    Result
-//  bulk string   parsed reply, nil
-//  nil           0, ErrNil
-//  other         0, error
-func Float64(reply interface{}, err error) (float64, error) {
-	if err != nil {
-		return 0, err
-	}
-	switch reply := reply.(type) {
-	case []byte:
-		n, err := strconv.ParseFloat(string(reply), 64)
-		return n, err
-	case nil:
-		return 0, ErrNil
-	case Error:
-		return 0, reply
-	}
-	return 0, fmt.Errorf("redigo: unexpected type for Float64, got type %T", reply)
-}
-
-// String is a helper that converts a command reply to a string. If err is not
-// equal to nil, then String returns "", err. Otherwise String converts the
-// reply to a string as follows:
-//
-//  Reply type      Result
-//  bulk string     string(reply), nil
-//  simple string   reply, nil
-//  nil             "",  ErrNil
-//  other           "",  error
-func String(reply interface{}, err error) (string, error) {
-	if err != nil {
-		return "", err
-	}
-	switch reply := reply.(type) {
-	case []byte:
-		return string(reply), nil
-	case string:
-		return reply, nil
-	case nil:
-		return "", ErrNil
-	case Error:
-		return "", reply
-	}
-	return "", fmt.Errorf("redigo: unexpected type for String, got type %T", reply)
-}
-
-// Bytes is a helper that converts a command reply to a slice of bytes. If err
-// is not equal to nil, then Bytes returns nil, err. Otherwise Bytes converts
-// the reply to a slice of bytes as follows:
-//
-//  Reply type      Result
-//  bulk string     reply, nil
-//  simple string   []byte(reply), nil
-//  nil             nil, ErrNil
-//  other           nil, error
-func Bytes(reply interface{}, err error) ([]byte, error) {
-	if err != nil {
-		return nil, err
-	}
-	switch reply := reply.(type) {
-	case []byte:
-		return reply, nil
-	case string:
-		return []byte(reply), nil
-	case nil:
-		return nil, ErrNil
-	case Error:
-		return nil, reply
-	}
-	return nil, fmt.Errorf("redigo: unexpected type for Bytes, got type %T", reply)
-}
-
-// Bool is a helper that converts a command reply to a boolean. If err is not
-// equal to nil, then Bool returns false, err. Otherwise Bool converts the
-// reply to boolean as follows:
-//
-//  Reply type      Result
-//  integer         value != 0, nil
-//  bulk string     strconv.ParseBool(reply)
-//  nil             false, ErrNil
-//  other           false, error
-func Bool(reply interface{}, err error) (bool, error) {
-	if err != nil {
-		return false, err
-	}
-	switch reply := reply.(type) {
-	case int64:
-		return reply != 0, nil
-	case []byte:
-		return strconv.ParseBool(string(reply))
-	case nil:
-		return false, ErrNil
-	case Error:
-		return false, reply
-	}
-	return false, fmt.Errorf("redigo: unexpected type for Bool, got type %T", reply)
-}
-
-// MultiBulk is a helper that converts an array command reply to a []interface{}.
-//
-// Deprecated: Use Values instead.
-func MultiBulk(reply interface{}, err error) ([]interface{}, error) { return Values(reply, err) }
-
-// Values is a helper that converts an array command reply to a []interface{}.
-// If err is not equal to nil, then Values returns nil, err. Otherwise, Values
-// converts the reply as follows:
-//
-//  Reply type      Result
-//  array           reply, nil
-//  nil             nil, ErrNil
-//  other           nil, error
-func Values(reply interface{}, err error) ([]interface{}, error) {
-	if err != nil {
-		return nil, err
-	}
-	switch reply := reply.(type) {
-	case []interface{}:
-		return reply, nil
-	case nil:
-		return nil, ErrNil
-	case Error:
-		return nil, reply
-	}
-	return nil, fmt.Errorf("redigo: unexpected type for Values, got type %T", reply)
-}
-
-func sliceHelper(reply interface{}, err error, name string, makeSlice func(int), assign func(int, interface{}) error) error {
-	if err != nil {
-		return err
-	}
-	switch reply := reply.(type) {
-	case []interface{}:
-		makeSlice(len(reply))
-		for i := range reply {
-			if reply[i] == nil {
-				continue
-			}
-			if err := assign(i, reply[i]); err != nil {
-				return err
-			}
-		}
-		return nil
-	case nil:
-		return ErrNil
-	case Error:
-		return reply
-	}
-	return fmt.Errorf("redigo: unexpected type for %s, got type %T", name, reply)
-}
-
-// Float64s is a helper that converts an array command reply to a []float64. If
-// err is not equal to nil, then Float64s returns nil, err. Nil array items are
-// converted to 0 in the output slice. Floats64 returns an error if an array
-// item is not a bulk string or nil.
-func Float64s(reply interface{}, err error) ([]float64, error) {
-	var result []float64
-	err = sliceHelper(reply, err, "Float64s", func(n int) { result = make([]float64, n) }, func(i int, v interface{}) error {
-		p, ok := v.([]byte)
-		if !ok {
-			return fmt.Errorf("redigo: unexpected element type for Floats64, got type %T", v)
-		}
-		f, err := strconv.ParseFloat(string(p), 64)
-		result[i] = f
-		return err
-	})
-	return result, err
-}
-
-// Strings is a helper that converts an array command reply to a []string. If
-// err is not equal to nil, then Strings returns nil, err. Nil array items are
-// converted to "" in the output slice. Strings returns an error if an array
-// item is not a bulk string or nil.
-func Strings(reply interface{}, err error) ([]string, error) {
-	var result []string
-	err = sliceHelper(reply, err, "Strings", func(n int) { result = make([]string, n) }, func(i int, v interface{}) error {
-		switch v := v.(type) {
-		case string:
-			result[i] = v
-			return nil
-		case []byte:
-			result[i] = string(v)
-			return nil
-		default:
-			return fmt.Errorf("redigo: unexpected element type for Strings, got type %T", v)
-		}
-	})
-	return result, err
-}
-
-// ByteSlices is a helper that converts an array command reply to a [][]byte.
-// If err is not equal to nil, then ByteSlices returns nil, err. Nil array
-// items are stay nil. ByteSlices returns an error if an array item is not a
-// bulk string or nil.
-func ByteSlices(reply interface{}, err error) ([][]byte, error) {
-	var result [][]byte
-	err = sliceHelper(reply, err, "ByteSlices", func(n int) { result = make([][]byte, n) }, func(i int, v interface{}) error {
-		p, ok := v.([]byte)
-		if !ok {
-			return fmt.Errorf("redigo: unexpected element type for ByteSlices, got type %T", v)
-		}
-		result[i] = p
-		return nil
-	})
-	return result, err
-}
-
-// Int64s is a helper that converts an array command reply to a []int64.
-// If err is not equal to nil, then Int64s returns nil, err. Nil array
-// items are stay nil. Int64s returns an error if an array item is not a
-// bulk string or nil.
-func Int64s(reply interface{}, err error) ([]int64, error) {
-	var result []int64
-	err = sliceHelper(reply, err, "Int64s", func(n int) { result = make([]int64, n) }, func(i int, v interface{}) error {
-		switch v := v.(type) {
-		case int64:
-			result[i] = v
-			return nil
-		case []byte:
-			n, err := strconv.ParseInt(string(v), 10, 64)
-			result[i] = n
-			return err
-		default:
-			return fmt.Errorf("redigo: unexpected element type for Int64s, got type %T", v)
-		}
-	})
-	return result, err
-}
-
-// Ints is a helper that converts an array command reply to a []in.
-// If err is not equal to nil, then Ints returns nil, err. Nil array
-// items are stay nil. Ints returns an error if an array item is not a
-// bulk string or nil.
-func Ints(reply interface{}, err error) ([]int, error) {
-	var result []int
-	err = sliceHelper(reply, err, "Ints", func(n int) { result = make([]int, n) }, func(i int, v interface{}) error {
-		switch v := v.(type) {
-		case int64:
-			n := int(v)
-			if int64(n) != v {
-				return strconv.ErrRange
-			}
-			result[i] = n
-			return nil
-		case []byte:
-			n, err := strconv.Atoi(string(v))
-			result[i] = n
-			return err
-		default:
-			return fmt.Errorf("redigo: unexpected element type for Ints, got type %T", v)
-		}
-	})
-	return result, err
-}
-
-// StringMap is a helper that converts an array of strings (alternating key, value)
-// into a map[string]string. The HGETALL and CONFIG GET commands return replies in this format.
-// Requires an even number of values in result.
-func StringMap(result interface{}, err error) (map[string]string, error) {
-	values, err := Values(result, err)
-	if err != nil {
-		return nil, err
-	}
-	if len(values)%2 != 0 {
-		return nil, errors.New("redigo: StringMap expects even number of values result")
-	}
-	m := make(map[string]string, len(values)/2)
-	for i := 0; i < len(values); i += 2 {
-		key, okKey := values[i].([]byte)
-		value, okValue := values[i+1].([]byte)
-		if !okKey || !okValue {
-			return nil, errors.New("redigo: StringMap key not a bulk string value")
-		}
-		m[string(key)] = string(value)
-	}
-	return m, nil
-}
-
-// IntMap is a helper that converts an array of strings (alternating key, value)
-// into a map[string]int. The HGETALL commands return replies in this format.
-// Requires an even number of values in result.
-func IntMap(result interface{}, err error) (map[string]int, error) {
-	values, err := Values(result, err)
-	if err != nil {
-		return nil, err
-	}
-	if len(values)%2 != 0 {
-		return nil, errors.New("redigo: IntMap expects even number of values result")
-	}
-	m := make(map[string]int, len(values)/2)
-	for i := 0; i < len(values); i += 2 {
-		key, ok := values[i].([]byte)
-		if !ok {
-			return nil, errors.New("redigo: IntMap key not a bulk string value")
-		}
-		value, err := Int(values[i+1], nil)
-		if err != nil {
-			return nil, err
-		}
-		m[string(key)] = value
-	}
-	return m, nil
-}
-
-// Int64Map is a helper that converts an array of strings (alternating key, value)
-// into a map[string]int64. The HGETALL commands return replies in this format.
-// Requires an even number of values in result.
-func Int64Map(result interface{}, err error) (map[string]int64, error) {
-	values, err := Values(result, err)
-	if err != nil {
-		return nil, err
-	}
-	if len(values)%2 != 0 {
-		return nil, errors.New("redigo: Int64Map expects even number of values result")
-	}
-	m := make(map[string]int64, len(values)/2)
-	for i := 0; i < len(values); i += 2 {
-		key, ok := values[i].([]byte)
-		if !ok {
-			return nil, errors.New("redigo: Int64Map key not a bulk string value")
-		}
-		value, err := Int64(values[i+1], nil)
-		if err != nil {
-			return nil, err
-		}
-		m[string(key)] = value
-	}
-	return m, nil
-}
-
-// Positions is a helper that converts an array of positions (lat, long)
-// into a [][2]float64. The GEOPOS command returns replies in this format.
-func Positions(result interface{}, err error) ([]*[2]float64, error) {
-	values, err := Values(result, err)
-	if err != nil {
-		return nil, err
-	}
-	positions := make([]*[2]float64, len(values))
-	for i := range values {
-		if values[i] == nil {
-			continue
-		}
-		p, ok := values[i].([]interface{})
-		if !ok {
-			return nil, fmt.Errorf("redigo: unexpected element type for interface slice, got type %T", values[i])
-		}
-		if len(p) != 2 {
-			return nil, fmt.Errorf("redigo: unexpected number of values for a member position, got %d", len(p))
-		}
-		lat, err := Float64(p[0], nil)
-		if err != nil {
-			return nil, err
-		}
-		long, err := Float64(p[1], nil)
-		if err != nil {
-			return nil, err
-		}
-		positions[i] = &[2]float64{lat, long}
-	}
-	return positions, nil
-}

vendor/github.com/garyburd/redigo/redis/scan.go

@@ -1,585 +0,0 @@
-// Copyright 2012 Gary Burd
-//
-// 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 redis
-
-import (
-	"errors"
-	"fmt"
-	"reflect"
-	"strconv"
-	"strings"
-	"sync"
-)
-
-func ensureLen(d reflect.Value, n int) {
-	if n > d.Cap() {
-		d.Set(reflect.MakeSlice(d.Type(), n, n))
-	} else {
-		d.SetLen(n)
-	}
-}
-
-func cannotConvert(d reflect.Value, s interface{}) error {
-	var sname string
-	switch s.(type) {
-	case string:
-		sname = "Redis simple string"
-	case Error:
-		sname = "Redis error"
-	case int64:
-		sname = "Redis integer"
-	case []byte:
-		sname = "Redis bulk string"
-	case []interface{}:
-		sname = "Redis array"
-	default:
-		sname = reflect.TypeOf(s).String()
-	}
-	return fmt.Errorf("cannot convert from %s to %s", sname, d.Type())
-}
-
-func convertAssignBulkString(d reflect.Value, s []byte) (err error) {
-	switch d.Type().Kind() {
-	case reflect.Float32, reflect.Float64:
-		var x float64
-		x, err = strconv.ParseFloat(string(s), d.Type().Bits())
-		d.SetFloat(x)
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		var x int64
-		x, err = strconv.ParseInt(string(s), 10, d.Type().Bits())
-		d.SetInt(x)
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		var x uint64
-		x, err = strconv.ParseUint(string(s), 10, d.Type().Bits())
-		d.SetUint(x)
-	case reflect.Bool:
-		var x bool
-		x, err = strconv.ParseBool(string(s))
-		d.SetBool(x)
-	case reflect.String:
-		d.SetString(string(s))
-	case reflect.Slice:
-		if d.Type().Elem().Kind() != reflect.Uint8 {
-			err = cannotConvert(d, s)
-		} else {
-			d.SetBytes(s)
-		}
-	default:
-		err = cannotConvert(d, s)
-	}
-	return
-}
-
-func convertAssignInt(d reflect.Value, s int64) (err error) {
-	switch d.Type().Kind() {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		d.SetInt(s)
-		if d.Int() != s {
-			err = strconv.ErrRange
-			d.SetInt(0)
-		}
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		if s < 0 {
-			err = strconv.ErrRange
-		} else {
-			x := uint64(s)
-			d.SetUint(x)
-			if d.Uint() != x {
-				err = strconv.ErrRange
-				d.SetUint(0)
-			}
-		}
-	case reflect.Bool:
-		d.SetBool(s != 0)
-	default:
-		err = cannotConvert(d, s)
-	}
-	return
-}
-
-func convertAssignValue(d reflect.Value, s interface{}) (err error) {
-	if d.Kind() != reflect.Ptr {
-		if d.CanAddr() {
-			d2 := d.Addr()
-			if d2.CanInterface() {
-				if scanner, ok := d2.Interface().(Scanner); ok {
-					return scanner.RedisScan(s)
-				}
-			}
-		}
-	} else if d.CanInterface() {
-		// Already a reflect.Ptr
-		if d.IsNil() {
-			d.Set(reflect.New(d.Type().Elem()))
-		}
-		if scanner, ok := d.Interface().(Scanner); ok {
-			return scanner.RedisScan(s)
-		}
-	}
-
-	switch s := s.(type) {
-	case []byte:
-		err = convertAssignBulkString(d, s)
-	case int64:
-		err = convertAssignInt(d, s)
-	default:
-		err = cannotConvert(d, s)
-	}
-	return err
-}
-
-func convertAssignArray(d reflect.Value, s []interface{}) error {
-	if d.Type().Kind() != reflect.Slice {
-		return cannotConvert(d, s)
-	}
-	ensureLen(d, len(s))
-	for i := 0; i < len(s); i++ {
-		if err := convertAssignValue(d.Index(i), s[i]); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func convertAssign(d interface{}, s interface{}) (err error) {
-	if scanner, ok := d.(Scanner); ok {
-		return scanner.RedisScan(s)
-	}
-
-	// Handle the most common destination types using type switches and
-	// fall back to reflection for all other types.
-	switch s := s.(type) {
-	case nil:
-		// ignore
-	case []byte:
-		switch d := d.(type) {
-		case *string:
-			*d = string(s)
-		case *int:
-			*d, err = strconv.Atoi(string(s))
-		case *bool:
-			*d, err = strconv.ParseBool(string(s))
-		case *[]byte:
-			*d = s
-		case *interface{}:
-			*d = s
-		case nil:
-			// skip value
-		default:
-			if d := reflect.ValueOf(d); d.Type().Kind() != reflect.Ptr {
-				err = cannotConvert(d, s)
-			} else {
-				err = convertAssignBulkString(d.Elem(), s)
-			}
-		}
-	case int64:
-		switch d := d.(type) {
-		case *int:
-			x := int(s)
-			if int64(x) != s {
-				err = strconv.ErrRange
-				x = 0
-			}
-			*d = x
-		case *bool:
-			*d = s != 0
-		case *interface{}:
-			*d = s
-		case nil:
-			// skip value
-		default:
-			if d := reflect.ValueOf(d); d.Type().Kind() != reflect.Ptr {
-				err = cannotConvert(d, s)
-			} else {
-				err = convertAssignInt(d.Elem(), s)
-			}
-		}
-	case string:
-		switch d := d.(type) {
-		case *string:
-			*d = s
-		case *interface{}:
-			*d = s
-		case nil:
-			// skip value
-		default:
-			err = cannotConvert(reflect.ValueOf(d), s)
-		}
-	case []interface{}:
-		switch d := d.(type) {
-		case *[]interface{}:
-			*d = s
-		case *interface{}:
-			*d = s
-		case nil:
-			// skip value
-		default:
-			if d := reflect.ValueOf(d); d.Type().Kind() != reflect.Ptr {
-				err = cannotConvert(d, s)
-			} else {
-				err = convertAssignArray(d.Elem(), s)
-			}
-		}
-	case Error:
-		err = s
-	default:
-		err = cannotConvert(reflect.ValueOf(d), s)
-	}
-	return
-}
-
-// Scan copies from src to the values pointed at by dest.
-//
-// Scan uses RedisScan if available otherwise:
-//
-// The values pointed at by dest must be an integer, float, boolean, string,
-// []byte, interface{} or slices of these types. Scan uses the standard strconv
-// package to convert bulk strings to numeric and boolean types.
-//
-// If a dest value is nil, then the corresponding src value is skipped.
-//
-// If a src element is nil, then the corresponding dest value is not modified.
-//
-// To enable easy use of Scan in a loop, Scan returns the slice of src
-// following the copied values.
-func Scan(src []interface{}, dest ...interface{}) ([]interface{}, error) {
-	if len(src) < len(dest) {
-		return nil, errors.New("redigo.Scan: array short")
-	}
-	var err error
-	for i, d := range dest {
-		err = convertAssign(d, src[i])
-		if err != nil {
-			err = fmt.Errorf("redigo.Scan: cannot assign to dest %d: %v", i, err)
-			break
-		}
-	}
-	return src[len(dest):], err
-}
-
-type fieldSpec struct {
-	name      string
-	index     []int
-	omitEmpty bool
-}
-
-type structSpec struct {
-	m map[string]*fieldSpec
-	l []*fieldSpec
-}
-
-func (ss *structSpec) fieldSpec(name []byte) *fieldSpec {
-	return ss.m[string(name)]
-}
-
-func compileStructSpec(t reflect.Type, depth map[string]int, index []int, ss *structSpec) {
-	for i := 0; i < t.NumField(); i++ {
-		f := t.Field(i)
-		switch {
-		case f.PkgPath != "" && !f.Anonymous:
-			// Ignore unexported fields.
-		case f.Anonymous:
-			// TODO: Handle pointers. Requires change to decoder and
-			// protection against infinite recursion.
-			if f.Type.Kind() == reflect.Struct {
-				compileStructSpec(f.Type, depth, append(index, i), ss)
-			}
-		default:
-			fs := &fieldSpec{name: f.Name}
-			tag := f.Tag.Get("redis")
-			p := strings.Split(tag, ",")
-			if len(p) > 0 {
-				if p[0] == "-" {
-					continue
-				}
-				if len(p[0]) > 0 {
-					fs.name = p[0]
-				}
-				for _, s := range p[1:] {
-					switch s {
-					case "omitempty":
-						fs.omitEmpty = true
-					default:
-						panic(fmt.Errorf("redigo: unknown field tag %s for type %s", s, t.Name()))
-					}
-				}
-			}
-			d, found := depth[fs.name]
-			if !found {
-				d = 1 << 30
-			}
-			switch {
-			case len(index) == d:
-				// At same depth, remove from result.
-				delete(ss.m, fs.name)
-				j := 0
-				for i := 0; i < len(ss.l); i++ {
-					if fs.name != ss.l[i].name {
-						ss.l[j] = ss.l[i]
-						j += 1
-					}
-				}
-				ss.l = ss.l[:j]
-			case len(index) < d:
-				fs.index = make([]int, len(index)+1)
-				copy(fs.index, index)
-				fs.index[len(index)] = i
-				depth[fs.name] = len(index)
-				ss.m[fs.name] = fs
-				ss.l = append(ss.l, fs)
-			}
-		}
-	}
-}
-
-var (
-	structSpecMutex  sync.RWMutex
-	structSpecCache  = make(map[reflect.Type]*structSpec)
-	defaultFieldSpec = &fieldSpec{}
-)
-
-func structSpecForType(t reflect.Type) *structSpec {
-
-	structSpecMutex.RLock()
-	ss, found := structSpecCache[t]
-	structSpecMutex.RUnlock()
-	if found {
-		return ss
-	}
-
-	structSpecMutex.Lock()
-	defer structSpecMutex.Unlock()
-	ss, found = structSpecCache[t]
-	if found {
-		return ss
-	}
-
-	ss = &structSpec{m: make(map[string]*fieldSpec)}
-	compileStructSpec(t, make(map[string]int), nil, ss)
-	structSpecCache[t] = ss
-	return ss
-}
-
-var errScanStructValue = errors.New("redigo.ScanStruct: value must be non-nil pointer to a struct")
-
-// ScanStruct scans alternating names and values from src to a struct. The
-// HGETALL and CONFIG GET commands return replies in this format.
-//
-// ScanStruct uses exported field names to match values in the response. Use
-// 'redis' field tag to override the name:
-//
-//      Field int `redis:"myName"`
-//
-// Fields with the tag redis:"-" are ignored.
-//
-// Each field uses RedisScan if available otherwise:
-// Integer, float, boolean, string and []byte fields are supported. Scan uses the
-// standard strconv package to convert bulk string values to numeric and
-// boolean types.
-//
-// If a src element is nil, then the corresponding field is not modified.
-func ScanStruct(src []interface{}, dest interface{}) error {
-	d := reflect.ValueOf(dest)
-	if d.Kind() != reflect.Ptr || d.IsNil() {
-		return errScanStructValue
-	}
-	d = d.Elem()
-	if d.Kind() != reflect.Struct {
-		return errScanStructValue
-	}
-	ss := structSpecForType(d.Type())
-
-	if len(src)%2 != 0 {
-		return errors.New("redigo.ScanStruct: number of values not a multiple of 2")
-	}
-
-	for i := 0; i < len(src); i += 2 {
-		s := src[i+1]
-		if s == nil {
-			continue
-		}
-		name, ok := src[i].([]byte)
-		if !ok {
-			return fmt.Errorf("redigo.ScanStruct: key %d not a bulk string value", i)
-		}
-		fs := ss.fieldSpec(name)
-		if fs == nil {
-			continue
-		}
-		if err := convertAssignValue(d.FieldByIndex(fs.index), s); err != nil {
-			return fmt.Errorf("redigo.ScanStruct: cannot assign field %s: %v", fs.name, err)
-		}
-	}
-	return nil
-}
-
-var (
-	errScanSliceValue = errors.New("redigo.ScanSlice: dest must be non-nil pointer to a struct")
-)
-
-// ScanSlice scans src to the slice pointed to by dest. The elements the dest
-// slice must be integer, float, boolean, string, struct or pointer to struct
-// values.
-//
-// Struct fields must be integer, float, boolean or string values. All struct
-// fields are used unless a subset is specified using fieldNames.
-func ScanSlice(src []interface{}, dest interface{}, fieldNames ...string) error {
-	d := reflect.ValueOf(dest)
-	if d.Kind() != reflect.Ptr || d.IsNil() {
-		return errScanSliceValue
-	}
-	d = d.Elem()
-	if d.Kind() != reflect.Slice {
-		return errScanSliceValue
-	}
-
-	isPtr := false
-	t := d.Type().Elem()
-	if t.Kind() == reflect.Ptr && t.Elem().Kind() == reflect.Struct {
-		isPtr = true
-		t = t.Elem()
-	}
-
-	if t.Kind() != reflect.Struct {
-		ensureLen(d, len(src))
-		for i, s := range src {
-			if s == nil {
-				continue
-			}
-			if err := convertAssignValue(d.Index(i), s); err != nil {
-				return fmt.Errorf("redigo.ScanSlice: cannot assign element %d: %v", i, err)
-			}
-		}
-		return nil
-	}
-
-	ss := structSpecForType(t)
-	fss := ss.l
-	if len(fieldNames) > 0 {
-		fss = make([]*fieldSpec, len(fieldNames))
-		for i, name := range fieldNames {
-			fss[i] = ss.m[name]
-			if fss[i] == nil {
-				return fmt.Errorf("redigo.ScanSlice: ScanSlice bad field name %s", name)
-			}
-		}
-	}
-
-	if len(fss) == 0 {
-		return errors.New("redigo.ScanSlice: no struct fields")
-	}
-
-	n := len(src) / len(fss)
-	if n*len(fss) != len(src) {
-		return errors.New("redigo.ScanSlice: length not a multiple of struct field count")
-	}
-
-	ensureLen(d, n)
-	for i := 0; i < n; i++ {
-		d := d.Index(i)
-		if isPtr {
-			if d.IsNil() {
-				d.Set(reflect.New(t))
-			}
-			d = d.Elem()
-		}
-		for j, fs := range fss {
-			s := src[i*len(fss)+j]
-			if s == nil {
-				continue
-			}
-			if err := convertAssignValue(d.FieldByIndex(fs.index), s); err != nil {
-				return fmt.Errorf("redigo.ScanSlice: cannot assign element %d to field %s: %v", i*len(fss)+j, fs.name, err)
-			}
-		}
-	}
-	return nil
-}
-
-// Args is a helper for constructing command arguments from structured values.
-type Args []interface{}
-
-// Add returns the result of appending value to args.
-func (args Args) Add(value ...interface{}) Args {
-	return append(args, value...)
-}
-
-// AddFlat returns the result of appending the flattened value of v to args.
-//
-// Maps are flattened by appending the alternating keys and map values to args.
-//
-// Slices are flattened by appending the slice elements to args.
-//
-// Structs are flattened by appending the alternating names and values of
-// exported fields to args. If v is a nil struct pointer, then nothing is
-// appended. The 'redis' field tag overrides struct field names. See ScanStruct
-// for more information on the use of the 'redis' field tag.
-//
-// Other types are appended to args as is.
-func (args Args) AddFlat(v interface{}) Args {
-	rv := reflect.ValueOf(v)
-	switch rv.Kind() {
-	case reflect.Struct:
-		args = flattenStruct(args, rv)
-	case reflect.Slice:
-		for i := 0; i < rv.Len(); i++ {
-			args = append(args, rv.Index(i).Interface())
-		}
-	case reflect.Map:
-		for _, k := range rv.MapKeys() {
-			args = append(args, k.Interface(), rv.MapIndex(k).Interface())
-		}
-	case reflect.Ptr:
-		if rv.Type().Elem().Kind() == reflect.Struct {
-			if !rv.IsNil() {
-				args = flattenStruct(args, rv.Elem())
-			}
-		} else {
-			args = append(args, v)
-		}
-	default:
-		args = append(args, v)
-	}
-	return args
-}
-
-func flattenStruct(args Args, v reflect.Value) Args {
-	ss := structSpecForType(v.Type())
-	for _, fs := range ss.l {
-		fv := v.FieldByIndex(fs.index)
-		if fs.omitEmpty {
-			var empty = false
-			switch fv.Kind() {
-			case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
-				empty = fv.Len() == 0
-			case reflect.Bool:
-				empty = !fv.Bool()
-			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-				empty = fv.Int() == 0
-			case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-				empty = fv.Uint() == 0
-			case reflect.Float32, reflect.Float64:
-				empty = fv.Float() == 0
-			case reflect.Interface, reflect.Ptr:
-				empty = fv.IsNil()
-			}
-			if empty {
-				continue
-			}
-		}
-		args = append(args, fs.name, fv.Interface())
-	}
-	return args
-}

vendor/github.com/garyburd/redigo/redis/script.go

@@ -1,91 +0,0 @@
-// Copyright 2012 Gary Burd
-//
-// 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 redis
-
-import (
-	"crypto/sha1"
-	"encoding/hex"
-	"io"
-	"strings"
-)
-
-// Script encapsulates the source, hash and key count for a Lua script. See
-// http://redis.io/commands/eval for information on scripts in Redis.
-type Script struct {
-	keyCount int
-	src      string
-	hash     string
-}
-
-// NewScript returns a new script object. If keyCount is greater than or equal
-// to zero, then the count is automatically inserted in the EVAL command
-// argument list. If keyCount is less than zero, then the application supplies
-// the count as the first value in the keysAndArgs argument to the Do, Send and
-// SendHash methods.
-func NewScript(keyCount int, src string) *Script {
-	h := sha1.New()
-	io.WriteString(h, src)
-	return &Script{keyCount, src, hex.EncodeToString(h.Sum(nil))}
-}
-
-func (s *Script) args(spec string, keysAndArgs []interface{}) []interface{} {
-	var args []interface{}
-	if s.keyCount < 0 {
-		args = make([]interface{}, 1+len(keysAndArgs))
-		args[0] = spec
-		copy(args[1:], keysAndArgs)
-	} else {
-		args = make([]interface{}, 2+len(keysAndArgs))
-		args[0] = spec
-		args[1] = s.keyCount
-		copy(args[2:], keysAndArgs)
-	}
-	return args
-}
-
-// Hash returns the script hash.
-func (s *Script) Hash() string {
-	return s.hash
-}
-
-// Do evaluates the script. Under the covers, Do optimistically evaluates the
-// script using the EVALSHA command. If the command fails because the script is
-// not loaded, then Do evaluates the script using the EVAL command (thus
-// causing the script to load).
-func (s *Script) Do(c Conn, keysAndArgs ...interface{}) (interface{}, error) {
-	v, err := c.Do("EVALSHA", s.args(s.hash, keysAndArgs)...)
-	if e, ok := err.(Error); ok && strings.HasPrefix(string(e), "NOSCRIPT ") {
-		v, err = c.Do("EVAL", s.args(s.src, keysAndArgs)...)
-	}
-	return v, err
-}
-
-// SendHash evaluates the script without waiting for the reply. The script is
-// evaluated with the EVALSHA command. The application must ensure that the
-// script is loaded by a previous call to Send, Do or Load methods.
-func (s *Script) SendHash(c Conn, keysAndArgs ...interface{}) error {
-	return c.Send("EVALSHA", s.args(s.hash, keysAndArgs)...)
-}
-
-// Send evaluates the script without waiting for the reply.
-func (s *Script) Send(c Conn, keysAndArgs ...interface{}) error {
-	return c.Send("EVAL", s.args(s.src, keysAndArgs)...)
-}
-
-// Load loads the script without evaluating it.
-func (s *Script) Load(c Conn) error {
-	_, err := c.Do("SCRIPT", "LOAD", s.src)
-	return err
-}

vendor/github.com/go-sql-driver/mysql/.gitignore

@@ -1,9 +0,0 @@
-.DS_Store
-.DS_Store?
-._*
-.Spotlight-V100
-.Trashes
-Icon?
-ehthumbs.db
-Thumbs.db
-.idea

vendor/github.com/go-sql-driver/mysql/.travis.yml

@@ -1,129 +0,0 @@
-sudo: false
-language: go
-go:
-  - 1.10.x
-  - 1.11.x
-  - 1.12.x
-  - 1.13.x
-  - master
-
-before_install:
-  - go get golang.org/x/tools/cmd/cover
-  - go get github.com/mattn/goveralls
-
-before_script:
-  - echo -e "[server]\ninnodb_log_file_size=256MB\ninnodb_buffer_pool_size=512MB\nmax_allowed_packet=16MB" | sudo tee -a /etc/mysql/my.cnf
-  - sudo service mysql restart
-  - .travis/wait_mysql.sh
-  - mysql -e 'create database gotest;'
-
-matrix:
-  include:
-    - env: DB=MYSQL8
-      sudo: required
-      dist: trusty
-      go: 1.10.x
-      services:
-        - docker
-      before_install:
-        - go get golang.org/x/tools/cmd/cover
-        - go get github.com/mattn/goveralls
-        - docker pull mysql:8.0
-        - docker run -d -p 127.0.0.1:3307:3306 --name mysqld -e MYSQL_DATABASE=gotest -e MYSQL_USER=gotest -e MYSQL_PASSWORD=secret -e MYSQL_ROOT_PASSWORD=verysecret
-          mysql:8.0 --innodb_log_file_size=256MB --innodb_buffer_pool_size=512MB --max_allowed_packet=16MB --local-infile=1
-        - cp .travis/docker.cnf ~/.my.cnf
-        - .travis/wait_mysql.sh
-      before_script:
-        - export MYSQL_TEST_USER=gotest
-        - export MYSQL_TEST_PASS=secret
-        - export MYSQL_TEST_ADDR=127.0.0.1:3307
-        - export MYSQL_TEST_CONCURRENT=1
-
-    - env: DB=MYSQL57
-      sudo: required
-      dist: trusty
-      go: 1.10.x
-      services:
-        - docker
-      before_install:
-        - go get golang.org/x/tools/cmd/cover
-        - go get github.com/mattn/goveralls
-        - docker pull mysql:5.7
-        - docker run -d -p 127.0.0.1:3307:3306 --name mysqld -e MYSQL_DATABASE=gotest -e MYSQL_USER=gotest -e MYSQL_PASSWORD=secret -e MYSQL_ROOT_PASSWORD=verysecret
-          mysql:5.7 --innodb_log_file_size=256MB --innodb_buffer_pool_size=512MB --max_allowed_packet=16MB --local-infile=1
-        - cp .travis/docker.cnf ~/.my.cnf
-        - .travis/wait_mysql.sh
-      before_script:
-        - export MYSQL_TEST_USER=gotest
-        - export MYSQL_TEST_PASS=secret
-        - export MYSQL_TEST_ADDR=127.0.0.1:3307
-        - export MYSQL_TEST_CONCURRENT=1
-
-    - env: DB=MARIA55
-      sudo: required
-      dist: trusty
-      go: 1.10.x
-      services:
-        - docker
-      before_install:
-        - go get golang.org/x/tools/cmd/cover
-        - go get github.com/mattn/goveralls
-        - docker pull mariadb:5.5
-        - docker run -d -p 127.0.0.1:3307:3306 --name mysqld -e MYSQL_DATABASE=gotest -e MYSQL_USER=gotest -e MYSQL_PASSWORD=secret -e MYSQL_ROOT_PASSWORD=verysecret
-          mariadb:5.5 --innodb_log_file_size=256MB --innodb_buffer_pool_size=512MB --max_allowed_packet=16MB --local-infile=1
-        - cp .travis/docker.cnf ~/.my.cnf
-        - .travis/wait_mysql.sh
-      before_script:
-        - export MYSQL_TEST_USER=gotest
-        - export MYSQL_TEST_PASS=secret
-        - export MYSQL_TEST_ADDR=127.0.0.1:3307
-        - export MYSQL_TEST_CONCURRENT=1
-
-    - env: DB=MARIA10_1
-      sudo: required
-      dist: trusty
-      go: 1.10.x
-      services:
-        - docker
-      before_install:
-        - go get golang.org/x/tools/cmd/cover
-        - go get github.com/mattn/goveralls
-        - docker pull mariadb:10.1
-        - docker run -d -p 127.0.0.1:3307:3306 --name mysqld -e MYSQL_DATABASE=gotest -e MYSQL_USER=gotest -e MYSQL_PASSWORD=secret -e MYSQL_ROOT_PASSWORD=verysecret
-          mariadb:10.1 --innodb_log_file_size=256MB --innodb_buffer_pool_size=512MB --max_allowed_packet=16MB --local-infile=1
-        - cp .travis/docker.cnf ~/.my.cnf
-        - .travis/wait_mysql.sh
-      before_script:
-        - export MYSQL_TEST_USER=gotest
-        - export MYSQL_TEST_PASS=secret
-        - export MYSQL_TEST_ADDR=127.0.0.1:3307
-        - export MYSQL_TEST_CONCURRENT=1
-
-    - os: osx
-      osx_image: xcode10.1
-      addons:
-        homebrew:
-          packages:
-            - mysql
-          update: true
-      go: 1.12.x
-      before_install:
-        - go get golang.org/x/tools/cmd/cover
-        - go get github.com/mattn/goveralls
-      before_script:
-        - echo -e "[server]\ninnodb_log_file_size=256MB\ninnodb_buffer_pool_size=512MB\nmax_allowed_packet=16MB\nlocal_infile=1" >> /usr/local/etc/my.cnf
-        - mysql.server start
-        - mysql -uroot -e 'CREATE USER gotest IDENTIFIED BY "secret"'
-        - mysql -uroot -e 'GRANT ALL ON *.* TO gotest'
-        - mysql -uroot -e 'create database gotest;'
-        - export MYSQL_TEST_USER=gotest
-        - export MYSQL_TEST_PASS=secret
-        - export MYSQL_TEST_ADDR=127.0.0.1:3306
-        - export MYSQL_TEST_CONCURRENT=1
-
-script:
-  - go test -v -covermode=count -coverprofile=coverage.out
-  - go vet ./...
-  - .travis/gofmt.sh
-after_script:
-  - $HOME/gopath/bin/goveralls -coverprofile=coverage.out -service=travis-ci

vendor/github.com/go-sql-driver/mysql/AUTHORS

@@ -1,105 +0,0 @@
-# This is the official list of Go-MySQL-Driver authors for copyright purposes.
-
-# If you are submitting a patch, please add your name or the name of the
-# organization which holds the copyright to this list in alphabetical order.
-
-# Names should be added to this file as
-#	Name <email address>
-# The email address is not required for organizations.
-# Please keep the list sorted.
-
-
-# Individual Persons
-
-Aaron Hopkins <go-sql-driver at die.net>
-Achille Roussel <achille.roussel at gmail.com>
-Alexey Palazhchenko <alexey.palazhchenko at gmail.com>
-Andrew Reid <andrew.reid at tixtrack.com>
-Arne Hormann <arnehormann at gmail.com>
-Asta Xie <xiemengjun at gmail.com>
-Bulat Gaifullin <gaifullinbf at gmail.com>
-Carlos Nieto <jose.carlos at menteslibres.net>
-Chris Moos <chris at tech9computers.com>
-Craig Wilson <craiggwilson at gmail.com>
-Daniel Montoya <dsmontoyam at gmail.com>
-Daniel Nichter <nil at codenode.com>
-Daniël van Eeden <git at myname.nl>
-Dave Protasowski <dprotaso at gmail.com>
-DisposaBoy <disposaboy at dby.me>
-Egor Smolyakov <egorsmkv at gmail.com>
-Erwan Martin <hello at erwan.io>
-Evan Shaw <evan at vendhq.com>
-Frederick Mayle <frederickmayle at gmail.com>
-Gustavo Kristic <gkristic at gmail.com>
-Hajime Nakagami <nakagami at gmail.com>
-Hanno Braun <mail at hannobraun.com>
-Henri Yandell <flamefew at gmail.com>
-Hirotaka Yamamoto <ymmt2005 at gmail.com>
-Huyiguang <hyg at webterren.com>
-ICHINOSE Shogo <shogo82148 at gmail.com>
-Ilia Cimpoes <ichimpoesh at gmail.com>
-INADA Naoki <songofacandy at gmail.com>
-Jacek Szwec <szwec.jacek at gmail.com>
-James Harr <james.harr at gmail.com>
-Jeff Hodges <jeff at somethingsimilar.com>
-Jeffrey Charles <jeffreycharles at gmail.com>
-Jerome Meyer <jxmeyer at gmail.com>
-Jiajia Zhong <zhong2plus at gmail.com>
-Jian Zhen <zhenjl at gmail.com>
-Joshua Prunier <joshua.prunier at gmail.com>
-Julien Lefevre <julien.lefevr at gmail.com>
-Julien Schmidt <go-sql-driver at julienschmidt.com>
-Justin Li <jli at j-li.net>
-Justin Nuß <nuss.justin at gmail.com>
-Kamil Dziedzic <kamil at klecza.pl>
-Kevin Malachowski <kevin at chowski.com>
-Kieron Woodhouse <kieron.woodhouse at infosum.com>
-Lennart Rudolph <lrudolph at hmc.edu>
-Leonardo YongUk Kim <dalinaum at gmail.com>
-Linh Tran Tuan <linhduonggnu at gmail.com>
-Lion Yang <lion at aosc.xyz>
-Luca Looz <luca.looz92 at gmail.com>
-Lucas Liu <extrafliu at gmail.com>
-Luke Scott <luke at webconnex.com>
-Maciej Zimnoch <maciej.zimnoch at codilime.com>
-Michael Woolnough <michael.woolnough at gmail.com>
-Nathanial Murphy <nathanial.murphy at gmail.com>
-Nicola Peduzzi <thenikso at gmail.com>
-Olivier Mengué <dolmen at cpan.org>
-oscarzhao <oscarzhaosl at gmail.com>
-Paul Bonser <misterpib at gmail.com>
-Peter Schultz <peter.schultz at classmarkets.com>
-Rebecca Chin <rchin at pivotal.io>
-Reed Allman <rdallman10 at gmail.com>
-Richard Wilkes <wilkes at me.com>
-Robert Russell <robert at rrbrussell.com>
-Runrioter Wung <runrioter at gmail.com>
-Shuode Li <elemount at qq.com>
-Simon J Mudd <sjmudd at pobox.com>
-Soroush Pour <me at soroushjp.com>
-Stan Putrya <root.vagner at gmail.com>
-Stanley Gunawan <gunawan.stanley at gmail.com>
-Steven Hartland <steven.hartland at multiplay.co.uk>
-Thomas Wodarek <wodarekwebpage at gmail.com>
-Tim Ruffles <timruffles at gmail.com>
-Tom Jenkinson <tom at tjenkinson.me>
-Vladimir Kovpak <cn007b at gmail.com>
-Xiangyu Hu <xiangyu.hu at outlook.com>
-Xiaobing Jiang <s7v7nislands at gmail.com>
-Xiuming Chen <cc at cxm.cc>
-Zhenye Xie <xiezhenye at gmail.com>
-
-# Organizations
-
-Barracuda Networks, Inc.
-Counting Ltd.
-DigitalOcean Inc.
-Facebook Inc.
-GitHub Inc.
-Google Inc.
-InfoSum Ltd.
-Keybase Inc.
-Multiplay Ltd.
-Percona LLC
-Pivotal Inc.
-Stripe Inc.

vendor/github.com/go-sql-driver/mysql/CHANGELOG.md

@@ -1,206 +0,0 @@
-## Version 1.5 (2020-01-07)
-
-Changes:
-
-  - Dropped support Go 1.9 and lower (#823, #829, #886, #1016, #1017)
-  - Improve buffer handling (#890)
-  - Document potentially insecure TLS configs (#901)
-  - Use a double-buffering scheme to prevent data races (#943)
-  - Pass uint64 values without converting them to string (#838, #955)
-  - Update collations and make utf8mb4 default (#877, #1054)
-  - Make NullTime compatible with sql.NullTime in Go 1.13+ (#995)
-  - Removed CloudSQL support (#993, #1007)
-  - Add Go Module support (#1003)
-
-New Features:
-
-  - Implement support of optional TLS (#900)
-  - Check connection liveness (#934, #964, #997, #1048, #1051, #1052)
-  - Implement Connector Interface (#941, #958, #1020, #1035)
-
-Bugfixes:
-
-  - Mark connections as bad on error during ping (#875)
-  - Mark connections as bad on error during dial (#867)
-  - Fix connection leak caused by rapid context cancellation (#1024)
-  - Mark connections as bad on error during Conn.Prepare (#1030)
-
-
-## Version 1.4.1 (2018-11-14)
-
-Bugfixes:
-
- - Fix TIME format for binary columns (#818)
- - Fix handling of empty auth plugin names (#835)
- - Fix caching_sha2_password with empty password (#826)
- - Fix canceled context broke mysqlConn (#862)
- - Fix OldAuthSwitchRequest support (#870)
- - Fix Auth Response packet for cleartext password (#887)
-
-## Version 1.4 (2018-06-03)
-
-Changes:
-
- - Documentation fixes (#530, #535, #567)
- - Refactoring (#575, #579, #580, #581, #603, #615, #704)
- - Cache column names (#444)
- - Sort the DSN parameters in DSNs generated from a config (#637)
- - Allow native password authentication by default (#644)
- - Use the default port if it is missing in the DSN (#668)
- - Removed the `strict` mode (#676)
- - Do not query `max_allowed_packet` by default (#680)
- - Dropped support Go 1.6 and lower (#696)
- - Updated `ConvertValue()` to match the database/sql/driver implementation (#760)
- - Document the usage of `0000-00-00T00:00:00` as the time.Time zero value (#783)
- - Improved the compatibility of the authentication system (#807)
-
-New Features:
-
- - Multi-Results support (#537)
- - `rejectReadOnly` DSN option (#604)
- - `context.Context` support (#608, #612, #627, #761)
- - Transaction isolation level support (#619, #744)
- - Read-Only transactions support (#618, #634)
- - `NewConfig` function which initializes a config with default values (#679)
- - Implemented the `ColumnType` interfaces (#667, #724)
- - Support for custom string types in `ConvertValue` (#623)
- - Implemented `NamedValueChecker`, improving support for uint64 with high bit set (#690, #709, #710)
- - `caching_sha2_password` authentication plugin support (#794, #800, #801, #802)
- - Implemented `driver.SessionResetter` (#779)
- - `sha256_password` authentication plugin support (#808)
-
-Bugfixes:
-
- - Use the DSN hostname as TLS default ServerName if `tls=true` (#564, #718)
- - Fixed LOAD LOCAL DATA INFILE for empty files (#590)
- - Removed columns definition cache since it sometimes cached invalid data (#592)
- - Don't mutate registered TLS configs (#600)
- - Make RegisterTLSConfig concurrency-safe (#613)
- - Handle missing auth data in the handshake packet correctly (#646)
- - Do not retry queries when data was written to avoid data corruption (#302, #736)
- - Cache the connection pointer for error handling before invalidating it (#678)
- - Fixed imports for appengine/cloudsql (#700)
- - Fix sending STMT_LONG_DATA for 0 byte data (#734)
- - Set correct capacity for []bytes read from length-encoded strings (#766)
- - Make RegisterDial concurrency-safe (#773)
-
-
-## Version 1.3 (2016-12-01)
-
-Changes:
-
- - Go 1.1 is no longer supported
- - Use decimals fields in MySQL to format time types (#249)
- - Buffer optimizations (#269)
- - TLS ServerName defaults to the host (#283)
- - Refactoring (#400, #410, #437)
- - Adjusted documentation for second generation CloudSQL (#485)
- - Documented DSN system var quoting rules (#502)
- - Made statement.Close() calls idempotent to avoid errors in Go 1.6+ (#512)
-
-New Features:
-
- - Enable microsecond resolution on TIME, DATETIME and TIMESTAMP (#249)
- - Support for returning table alias on Columns() (#289, #359, #382)
- - Placeholder interpolation, can be actived with the DSN parameter `interpolateParams=true` (#309, #318, #490)
- - Support for uint64 parameters with high bit set (#332, #345)
- - Cleartext authentication plugin support (#327)
- - Exported ParseDSN function and the Config struct (#403, #419, #429)
- - Read / Write timeouts (#401)
- - Support for JSON field type (#414)
- - Support for multi-statements and multi-results (#411, #431)
- - DSN parameter to set the driver-side max_allowed_packet value manually (#489)
- - Native password authentication plugin support (#494, #524)
-
-Bugfixes:
-
- - Fixed handling of queries without columns and rows (#255)
- - Fixed a panic when SetKeepAlive() failed (#298)
- - Handle ERR packets while reading rows (#321)
- - Fixed reading NULL length-encoded integers in MySQL 5.6+ (#349)
- - Fixed absolute paths support in LOAD LOCAL DATA INFILE (#356)
- - Actually zero out bytes in handshake response (#378)
- - Fixed race condition in registering LOAD DATA INFILE handler (#383)
- - Fixed tests with MySQL 5.7.9+ (#380)
- - QueryUnescape TLS config names (#397)
- - Fixed "broken pipe" error by writing to closed socket (#390)
- - Fixed LOAD LOCAL DATA INFILE buffering (#424)
- - Fixed parsing of floats into float64 when placeholders are used (#434)
- - Fixed DSN tests with Go 1.7+ (#459)
- - Handle ERR packets while waiting for EOF (#473)
- - Invalidate connection on error while discarding additional results (#513)
- - Allow terminating packets of length 0 (#516)
-
-
-## Version 1.2 (2014-06-03)
-
-Changes:
-
- - We switched back to a "rolling release". `go get` installs the current master branch again
- - Version v1 of the driver will not be maintained anymore. Go 1.0 is no longer supported by this driver
- - Exported errors to allow easy checking from application code
- - Enabled TCP Keepalives on TCP connections
- - Optimized INFILE handling (better buffer size calculation, lazy init, ...)
- - The DSN parser also checks for a missing separating slash
- - Faster binary date / datetime to string formatting
- - Also exported the MySQLWarning type
- - mysqlConn.Close returns the first error encountered instead of ignoring all errors
- - writePacket() automatically writes the packet size to the header
- - readPacket() uses an iterative approach instead of the recursive approach to merge splitted packets
-
-New Features:
-
- - `RegisterDial` allows the usage of a custom dial function to establish the network connection
- - Setting the connection collation is possible with the `collation` DSN parameter. This parameter should be preferred over the `charset` parameter
- - Logging of critical errors is configurable with `SetLogger`
- - Google CloudSQL support
-
-Bugfixes:
-
- - Allow more than 32 parameters in prepared statements
- - Various old_password fixes
- - Fixed TestConcurrent test to pass Go's race detection
- - Fixed appendLengthEncodedInteger for large numbers
- - Renamed readLengthEnodedString to readLengthEncodedString and skipLengthEnodedString to skipLengthEncodedString (fixed typo)
-
-
-## Version 1.1 (2013-11-02)
-
-Changes:
-
-  - Go-MySQL-Driver now requires Go 1.1
-  - Connections now use the collation `utf8_general_ci` by default. Adding `&charset=UTF8` to the DSN should not be necessary anymore
-  - Made closing rows and connections error tolerant. This allows for example deferring rows.Close() without checking for errors
-  - `[]byte(nil)` is now treated as a NULL value. Before, it was treated like an empty string / `[]byte("")`
-  - DSN parameter values must now be url.QueryEscape'ed. This allows text values to contain special characters, such as '&'.
-  - Use the IO buffer also for writing. This results in zero allocations (by the driver) for most queries
-  - Optimized the buffer for reading
-  - stmt.Query now caches column metadata
-  - New Logo
-  - Changed the copyright header to include all contributors
-  - Improved the LOAD INFILE documentation
-  - The driver struct is now exported to make the driver directly accessible
-  - Refactored the driver tests
-  - Added more benchmarks and moved all to a separate file
-  - Other small refactoring
-
-New Features:
-
-  - Added *old_passwords* support: Required in some cases, but must be enabled by adding `allowOldPasswords=true` to the DSN since it is insecure
-  - Added a `clientFoundRows` parameter: Return the number of matching rows instead of the number of rows changed on UPDATEs
-  - Added TLS/SSL support: Use a TLS/SSL encrypted connection to the server. Custom TLS configs can be registered and used
-
-Bugfixes:
-
-  - Fixed MySQL 4.1 support: MySQL 4.1 sends packets with lengths which differ from the specification
-  - Convert to DB timezone when inserting `time.Time`
-  - Splitted packets (more than 16MB) are now merged correctly
-  - Fixed false positive `io.EOF` errors when the data was fully read
-  - Avoid panics on reuse of closed connections
-  - Fixed empty string producing false nil values
-  - Fixed sign byte for positive TIME fields
-
-
-## Version 1.0 (2013-05-14)
-
-Initial Release

vendor/github.com/go-sql-driver/mysql/LICENSE

@@ -1,373 +0,0 @@
-Mozilla Public License Version 2.0
-==================================
-
-1. Definitions
---------------
-
-1.1. "Contributor"
-    means each individual or legal entity that creates, contributes to
-    the creation of, or owns Covered Software.
-
-1.2. "Contributor Version"
-    means the combination of the Contributions of others (if any) used
-    by a Contributor and that particular Contributor's Contribution.
-
-1.3. "Contribution"
-    means Covered Software of a particular Contributor.
-
-1.4. "Covered Software"
-    means Source Code Form to which the initial Contributor has attached
-    the notice in Exhibit A, the Executable Form of such Source Code
-    Form, and Modifications of such Source Code Form, in each case
-    including portions thereof.
-
-1.5. "Incompatible With Secondary Licenses"
-    means
-
-    (a) that the initial Contributor has attached the notice described
-        in Exhibit B to the Covered Software; or
-
-    (b) that the Covered Software was made available under the terms of
-        version 1.1 or earlier of the License, but not also under the
-        terms of a Secondary License.
-
-1.6. "Executable Form"
-    means any form of the work other than Source Code Form.
-
-1.7. "Larger Work"
-    means a work that combines Covered Software with other material, in 
-    a separate file or files, that is not Covered Software.
-
-1.8. "License"
-    means this document.
-
-1.9. "Licensable"
-    means having the right to grant, to the maximum extent possible,
-    whether at the time of the initial grant or subsequently, any and
-    all of the rights conveyed by this License.
-
-1.10. "Modifications"
-    means any of the following:
-
-    (a) any file in Source Code Form that results from an addition to,
-        deletion from, or modification of the contents of Covered
-        Software; or
-
-    (b) any new file in Source Code Form that contains any Covered
-        Software.
-
-1.11. "Patent Claims" of a Contributor
-    means any patent claim(s), including without limitation, method,
-    process, and apparatus claims, in any patent Licensable by such
-    Contributor that would be infringed, but for the grant of the
-    License, by the making, using, selling, offering for sale, having
-    made, import, or transfer of either its Contributions or its
-    Contributor Version.
-
-1.12. "Secondary License"
-    means either the GNU General Public License, Version 2.0, the GNU
-    Lesser General Public License, Version 2.1, the GNU Affero General
-    Public License, Version 3.0, or any later versions of those
-    licenses.
-
-1.13. "Source Code Form"
-    means the form of the work preferred for making modifications.
-
-1.14. "You" (or "Your")
-    means an individual or a legal entity exercising rights under this
-    License. For legal entities, "You" includes any entity that
-    controls, is controlled by, or is under common control with You. For
-    purposes of this definition, "control" means (a) the power, direct
-    or indirect, to cause the direction or management of such entity,
-    whether by contract or otherwise, or (b) ownership of more than
-    fifty percent (50%) of the outstanding shares or beneficial
-    ownership of such entity.
-
-2. License Grants and Conditions
---------------------------------
-
-2.1. Grants
-
-Each Contributor hereby grants You a world-wide, royalty-free,
-non-exclusive license:
-
-(a) under intellectual property rights (other than patent or trademark)
-    Licensable by such Contributor to use, reproduce, make available,
-    modify, display, perform, distribute, and otherwise exploit its
-    Contributions, either on an unmodified basis, with Modifications, or
-    as part of a Larger Work; and
-
-(b) under Patent Claims of such Contributor to make, use, sell, offer
-    for sale, have made, import, and otherwise transfer either its
-    Contributions or its Contributor Version.
-
-2.2. Effective Date
-
-The licenses granted in Section 2.1 with respect to any Contribution
-become effective for each Contribution on the date the Contributor first
-distributes such Contribution.
-
-2.3. Limitations on Grant Scope
-
-The licenses granted in this Section 2 are the only rights granted under
-this License. No additional rights or licenses will be implied from the
-distribution or licensing of Covered Software under this License.
-Notwithstanding Section 2.1(b) above, no patent license is granted by a
-Contributor:
-
-(a) for any code that a Contributor has removed from Covered Software;
-    or
-
-(b) for infringements caused by: (i) Your and any other third party's
-    modifications of Covered Software, or (ii) the combination of its
-    Contributions with other software (except as part of its Contributor
-    Version); or
-
-(c) under Patent Claims infringed by Covered Software in the absence of
-    its Contributions.
-
-This License does not grant any rights in the trademarks, service marks,
-or logos of any Contributor (except as may be necessary to comply with
-the notice requirements in Section 3.4).
-
-2.4. Subsequent Licenses
-
-No Contributor makes additional grants as a result of Your choice to
-distribute the Covered Software under a subsequent version of this
-License (see Section 10.2) or under the terms of a Secondary License (if
-permitted under the terms of Section 3.3).
-
-2.5. Representation
-
-Each Contributor represents that the Contributor believes its
-Contributions are its original creation(s) or it has sufficient rights
-to grant the rights to its Contributions conveyed by this License.
-
-2.6. Fair Use
-
-This License is not intended to limit any rights You have under
-applicable copyright doctrines of fair use, fair dealing, or other
-equivalents.
-
-2.7. Conditions
-
-Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
-in Section 2.1.
-
-3. Responsibilities
--------------------
-
-3.1. Distribution of Source Form
-
-All distribution of Covered Software in Source Code Form, including any
-Modifications that You create or to which You contribute, must be under
-the terms of this License. You must inform recipients that the Source
-Code Form of the Covered Software is governed by the terms of this
-License, and how they can obtain a copy of this License. You may not
-attempt to alter or restrict the recipients' rights in the Source Code
-Form.
-
-3.2. Distribution of Executable Form
-
-If You distribute Covered Software in Executable Form then:
-
-(a) such Covered Software must also be made available in Source Code
-    Form, as described in Section 3.1, and You must inform recipients of
-    the Executable Form how they can obtain a copy of such Source Code
-    Form by reasonable means in a timely manner, at a charge no more
-    than the cost of distribution to the recipient; and
-
-(b) You may distribute such Executable Form under the terms of this
-    License, or sublicense it under different terms, provided that the
-    license for the Executable Form does not attempt to limit or alter
-    the recipients' rights in the Source Code Form under this License.
-
-3.3. Distribution of a Larger Work
-
-You may create and distribute a Larger Work under terms of Your choice,
-provided that You also comply with the requirements of this License for
-the Covered Software. If the Larger Work is a combination of Covered
-Software with a work governed by one or more Secondary Licenses, and the
-Covered Software is not Incompatible With Secondary Licenses, this
-License permits You to additionally distribute such Covered Software
-under the terms of such Secondary License(s), so that the recipient of
-the Larger Work may, at their option, further distribute the Covered
-Software under the terms of either this License or such Secondary
-License(s).
-
-3.4. Notices
-
-You may not remove or alter the substance of any license notices
-(including copyright notices, patent notices, disclaimers of warranty,
-or limitations of liability) contained within the Source Code Form of
-the Covered Software, except that You may alter any license notices to
-the extent required to remedy known factual inaccuracies.
-
-3.5. Application of Additional Terms
-
-You may choose to offer, and to charge a fee for, warranty, support,
-indemnity or liability obligations to one or more recipients of Covered
-Software. However, You may do so only on Your own behalf, and not on
-behalf of any Contributor. You must make it absolutely clear that any
-such warranty, support, indemnity, or liability obligation is offered by
-You alone, and You hereby agree to indemnify every Contributor for any
-liability incurred by such Contributor as a result of warranty, support,
-indemnity or liability terms You offer. You may include additional
-disclaimers of warranty and limitations of liability specific to any
-jurisdiction.
-
-4. Inability to Comply Due to Statute or Regulation
----------------------------------------------------
-
-If it is impossible for You to comply with any of the terms of this
-License with respect to some or all of the Covered Software due to
-statute, judicial order, or regulation then You must: (a) comply with
-the terms of this License to the maximum extent possible; and (b)
-describe the limitations and the code they affect. Such description must
-be placed in a text file included with all distributions of the Covered
-Software under this License. Except to the extent prohibited by statute
-or regulation, such description must be sufficiently detailed for a
-recipient of ordinary skill to be able to understand it.
-
-5. Termination
---------------
-
-5.1. The rights granted under this License will terminate automatically
-if You fail to comply with any of its terms. However, if You become
-compliant, then the rights granted under this License from a particular
-Contributor are reinstated (a) provisionally, unless and until such
-Contributor explicitly and finally terminates Your grants, and (b) on an
-ongoing basis, if such Contributor fails to notify You of the
-non-compliance by some reasonable means prior to 60 days after You have
-come back into compliance. Moreover, Your grants from a particular
-Contributor are reinstated on an ongoing basis if such Contributor
-notifies You of the non-compliance by some reasonable means, this is the
-first time You have received notice of non-compliance with this License
-from such Contributor, and You become compliant prior to 30 days after
-Your receipt of the notice.
-
-5.2. If You initiate litigation against any entity by asserting a patent
-infringement claim (excluding declaratory judgment actions,
-counter-claims, and cross-claims) alleging that a Contributor Version
-directly or indirectly infringes any patent, then the rights granted to
-You by any and all Contributors for the Covered Software under Section
-2.1 of this License shall terminate.
-
-5.3. In the event of termination under Sections 5.1 or 5.2 above, all
-end user license agreements (excluding distributors and resellers) which
-have been validly granted by You or Your distributors under this License
-prior to termination shall survive termination.
-
-************************************************************************
-*                                                                      *
-*  6. Disclaimer of Warranty                                           *
-*  -------------------------                                           *
-*                                                                      *
-*  Covered Software is provided under this License on an "as is"       *
-*  basis, without warranty of any kind, either expressed, implied, or  *
-*  statutory, including, without limitation, warranties that the       *
-*  Covered Software is free of defects, merchantable, fit for a        *
-*  particular purpose or non-infringing. The entire risk as to the     *
-*  quality and performance of the Covered Software is with You.        *
-*  Should any Covered Software prove defective in any respect, You     *
-*  (not any Contributor) assume the cost of any necessary servicing,   *
-*  repair, or correction. This disclaimer of warranty constitutes an   *
-*  essential part of this License. No use of any Covered Software is   *
-*  authorized under this License except under this disclaimer.         *
-*                                                                      *
-************************************************************************
-
-************************************************************************
-*                                                                      *
-*  7. Limitation of Liability                                          *
-*  --------------------------                                          *
-*                                                                      *
-*  Under no circumstances and under no legal theory, whether tort      *
-*  (including negligence), contract, or otherwise, shall any           *
-*  Contributor, or anyone who distributes Covered Software as          *
-*  permitted above, be liable to You for any direct, indirect,         *
-*  special, incidental, or consequential damages of any character      *
-*  including, without limitation, damages for lost profits, loss of    *
-*  goodwill, work stoppage, computer failure or malfunction, or any    *
-*  and all other commercial damages or losses, even if such party      *
-*  shall have been informed of the possibility of such damages. This   *
-*  limitation of liability shall not apply to liability for death or   *
-*  personal injury resulting from such party's negligence to the       *
-*  extent applicable law prohibits such limitation. Some               *
-*  jurisdictions do not allow the exclusion or limitation of           *
-*  incidental or consequential damages, so this exclusion and          *
-*  limitation may not apply to You.                                    *
-*                                                                      *
-************************************************************************
-
-8. Litigation
--------------
-
-Any litigation relating to this License may be brought only in the
-courts of a jurisdiction where the defendant maintains its principal
-place of business and such litigation shall be governed by laws of that
-jurisdiction, without reference to its conflict-of-law provisions.
-Nothing in this Section shall prevent a party's ability to bring
-cross-claims or counter-claims.
-
-9. Miscellaneous
-----------------
-
-This License represents the complete agreement concerning the subject
-matter hereof. If any provision of this License is held to be
-unenforceable, such provision shall be reformed only to the extent
-necessary to make it enforceable. Any law or regulation which provides
-that the language of a contract shall be construed against the drafter
-shall not be used to construe this License against a Contributor.
-
-10. Versions of the License
----------------------------
-
-10.1. New Versions
-
-Mozilla Foundation is the license steward. Except as provided in Section
-10.3, no one other than the license steward has the right to modify or
-publish new versions of this License. Each version will be given a
-distinguishing version number.
-
-10.2. Effect of New Versions
-
-You may distribute the Covered Software under the terms of the version
-of the License under which You originally received the Covered Software,
-or under the terms of any subsequent version published by the license
-steward.
-
-10.3. Modified Versions
-
-If you create software not governed by this License, and you want to
-create a new license for such software, you may create and use a
-modified version of this License if you rename the license and remove
-any references to the name of the license steward (except to note that
-such modified license differs from this License).
-
-10.4. Distributing Source Code Form that is Incompatible With Secondary
-Licenses
-
-If You choose to distribute Source Code Form that is Incompatible With
-Secondary Licenses under the terms of this version of the License, the
-notice described in Exhibit B of this License must be attached.
-
-Exhibit A - Source Code Form License Notice
--------------------------------------------
-
-  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/.
-
-If it is not possible or desirable to put the notice in a particular
-file, then You may include the notice in a location (such as a LICENSE
-file in a relevant directory) where a recipient would be likely to look
-for such a notice.
-
-You may add additional accurate notices of copyright ownership.
-
-Exhibit B - "Incompatible With Secondary Licenses" Notice
----------------------------------------------------------
-
-  This Source Code Form is "Incompatible With Secondary Licenses", as
-  defined by the Mozilla Public License, v. 2.0.

vendor/github.com/go-sql-driver/mysql/README.md

@@ -1,501 +0,0 @@
-# Go-MySQL-Driver
-
-A MySQL-Driver for Go's [database/sql](https://golang.org/pkg/database/sql/) package
-
-![Go-MySQL-Driver logo](https://raw.github.com/wiki/go-sql-driver/mysql/gomysql_m.png "Golang Gopher holding the MySQL Dolphin")
-
----------------------------------------
-  * [Features](#features)
-  * [Requirements](#requirements)
-  * [Installation](#installation)
-  * [Usage](#usage)
-    * [DSN (Data Source Name)](#dsn-data-source-name)
-      * [Password](#password)
-      * [Protocol](#protocol)
-      * [Address](#address)
-      * [Parameters](#parameters)
-      * [Examples](#examples)
-    * [Connection pool and timeouts](#connection-pool-and-timeouts)
-    * [context.Context Support](#contextcontext-support)
-    * [ColumnType Support](#columntype-support)
-    * [LOAD DATA LOCAL INFILE support](#load-data-local-infile-support)
-    * [time.Time support](#timetime-support)
-    * [Unicode support](#unicode-support)
-  * [Testing / Development](#testing--development)
-  * [License](#license)
-
----------------------------------------
-
-## Features
-  * Lightweight and [fast](https://github.com/go-sql-driver/sql-benchmark "golang MySQL-Driver performance")
-  * Native Go implementation. No C-bindings, just pure Go
-  * Connections over TCP/IPv4, TCP/IPv6, Unix domain sockets or [custom protocols](https://godoc.org/github.com/go-sql-driver/mysql#DialFunc)
-  * Automatic handling of broken connections
-  * Automatic Connection Pooling *(by database/sql package)*
-  * Supports queries larger than 16MB
-  * Full [`sql.RawBytes`](https://golang.org/pkg/database/sql/#RawBytes) support.
-  * Intelligent `LONG DATA` handling in prepared statements
-  * Secure `LOAD DATA LOCAL INFILE` support with file Whitelisting and `io.Reader` support
-  * Optional `time.Time` parsing
-  * Optional placeholder interpolation
-
-## Requirements
-  * Go 1.10 or higher. We aim to support the 3 latest versions of Go.
-  * MySQL (4.1+), MariaDB, Percona Server, Google CloudSQL or Sphinx (2.2.3+)
-
----------------------------------------
-
-## Installation
-Simple install the package to your [$GOPATH](https://github.com/golang/go/wiki/GOPATH "GOPATH") with the [go tool](https://golang.org/cmd/go/ "go command") from shell:
-```bash
-$ go get -u github.com/go-sql-driver/mysql
-```
-Make sure [Git is installed](https://git-scm.com/downloads) on your machine and in your system's `PATH`.
-
-## Usage
-_Go MySQL Driver_ is an implementation of Go's `database/sql/driver` interface. You only need to import the driver and can use the full [`database/sql`](https://golang.org/pkg/database/sql/) API then.
-
-Use `mysql` as `driverName` and a valid [DSN](#dsn-data-source-name)  as `dataSourceName`:
-```go
-import "database/sql"
-import _ "github.com/go-sql-driver/mysql"
-
-db, err := sql.Open("mysql", "user:password@/dbname")
-```
-
-[Examples are available in our Wiki](https://github.com/go-sql-driver/mysql/wiki/Examples "Go-MySQL-Driver Examples").
-
-
-### DSN (Data Source Name)
-
-The Data Source Name has a common format, like e.g. [PEAR DB](http://pear.php.net/manual/en/package.database.db.intro-dsn.php) uses it, but without type-prefix (optional parts marked by squared brackets):
-```
-[username[:password]@][protocol[(address)]]/dbname[?param1=value1&...&paramN=valueN]
-```
-
-A DSN in its fullest form:
-```
-username:password@protocol(address)/dbname?param=value
-```
-
-Except for the databasename, all values are optional. So the minimal DSN is:
-```
-/dbname
-```
-
-If you do not want to preselect a database, leave `dbname` empty:
-```
-/
-```
-This has the same effect as an empty DSN string:
-```
-
-```
-
-Alternatively, [Config.FormatDSN](https://godoc.org/github.com/go-sql-driver/mysql#Config.FormatDSN) can be used to create a DSN string by filling a struct.
-
-#### Password
-Passwords can consist of any character. Escaping is **not** necessary.
-
-#### Protocol
-See [net.Dial](https://golang.org/pkg/net/#Dial) for more information which networks are available.
-In general you should use an Unix domain socket if available and TCP otherwise for best performance.
-
-#### Address
-For TCP and UDP networks, addresses have the form `host[:port]`.
-If `port` is omitted, the default port will be used.
-If `host` is a literal IPv6 address, it must be enclosed in square brackets.
-The functions [net.JoinHostPort](https://golang.org/pkg/net/#JoinHostPort) and [net.SplitHostPort](https://golang.org/pkg/net/#SplitHostPort) manipulate addresses in this form.
-
-For Unix domain sockets the address is the absolute path to the MySQL-Server-socket, e.g. `/var/run/mysqld/mysqld.sock` or `/tmp/mysql.sock`.
-
-#### Parameters
-*Parameters are case-sensitive!*
-
-Notice that any of `true`, `TRUE`, `True` or `1` is accepted to stand for a true boolean value. Not surprisingly, false can be specified as any of: `false`, `FALSE`, `False` or `0`.
-
-##### `allowAllFiles`
-
-```
-Type:           bool
-Valid Values:   true, false
-Default:        false
-```
-
-`allowAllFiles=true` disables the file Whitelist for `LOAD DATA LOCAL INFILE` and allows *all* files.
-[*Might be insecure!*](http://dev.mysql.com/doc/refman/5.7/en/load-data-local.html)
-
-##### `allowCleartextPasswords`
-
-```
-Type:           bool
-Valid Values:   true, false
-Default:        false
-```
-
-`allowCleartextPasswords=true` allows using the [cleartext client side plugin](http://dev.mysql.com/doc/en/cleartext-authentication-plugin.html) if required by an account, such as one defined with the [PAM authentication plugin](http://dev.mysql.com/doc/en/pam-authentication-plugin.html). Sending passwords in clear text may be a security problem in some configurations. To avoid problems if there is any possibility that the password would be intercepted, clients should connect to MySQL Server using a method that protects the password. Possibilities include [TLS / SSL](#tls), IPsec, or a private network.
-
-##### `allowNativePasswords`
-
-```
-Type:           bool
-Valid Values:   true, false
-Default:        true
-```
-`allowNativePasswords=false` disallows the usage of MySQL native password method.
-
-##### `allowOldPasswords`
-
-```
-Type:           bool
-Valid Values:   true, false
-Default:        false
-```
-`allowOldPasswords=true` allows the usage of the insecure old password method. This should be avoided, but is necessary in some cases. See also [the old_passwords wiki page](https://github.com/go-sql-driver/mysql/wiki/old_passwords).
-
-##### `charset`
-
-```
-Type:           string
-Valid Values:   <name>
-Default:        none
-```
-
-Sets the charset used for client-server interaction (`"SET NAMES <value>"`). If multiple charsets are set (separated by a comma), the following charset is used if setting the charset failes. This enables for example support for `utf8mb4` ([introduced in MySQL 5.5.3](http://dev.mysql.com/doc/refman/5.5/en/charset-unicode-utf8mb4.html)) with fallback to `utf8` for older servers (`charset=utf8mb4,utf8`).
-
-Usage of the `charset` parameter is discouraged because it issues additional queries to the server.
-Unless you need the fallback behavior, please use `collation` instead.
-
-##### `checkConnLiveness`
-
-```
-Type:           bool
-Valid Values:   true, false
-Default:        true
-```
-
-On supported platforms connections retrieved from the connection pool are checked for liveness before using them. If the check fails, the respective connection is marked as bad and the query retried with another connection.
-`checkConnLiveness=false` disables this liveness check of connections.
-
-##### `collation`
-
-```
-Type:           string
-Valid Values:   <name>
-Default:        utf8mb4_general_ci
-```
-
-Sets the collation used for client-server interaction on connection. In contrast to `charset`, `collation` does not issue additional queries. If the specified collation is unavailable on the target server, the connection will fail.
-
-A list of valid charsets for a server is retrievable with `SHOW COLLATION`.
-
-The default collation (`utf8mb4_general_ci`) is supported from MySQL 5.5.  You should use an older collation (e.g. `utf8_general_ci`) for older MySQL.
-
-Collations for charset "ucs2", "utf16", "utf16le", and "utf32" can not be used ([ref](https://dev.mysql.com/doc/refman/5.7/en/charset-connection.html#charset-connection-impermissible-client-charset)).
-
-
-##### `clientFoundRows`
-
-```
-Type:           bool
-Valid Values:   true, false
-Default:        false
-```
-
-`clientFoundRows=true` causes an UPDATE to return the number of matching rows instead of the number of rows changed.
-
-##### `columnsWithAlias`
-
-```
-Type:           bool
-Valid Values:   true, false
-Default:        false
-```
-
-When `columnsWithAlias` is true, calls to `sql.Rows.Columns()` will return the table alias and the column name separated by a dot. For example:
-
-```
-SELECT u.id FROM users as u
-```
-
-will return `u.id` instead of just `id` if `columnsWithAlias=true`.
-
-##### `interpolateParams`
-
-```
-Type:           bool
-Valid Values:   true, false
-Default:        false
-```
-
-If `interpolateParams` is true, placeholders (`?`) in calls to `db.Query()` and `db.Exec()` are interpolated into a single query string with given parameters. This reduces the number of roundtrips, since the driver has to prepare a statement, execute it with given parameters and close the statement again with `interpolateParams=false`.
-
-*This can not be used together with the multibyte encodings BIG5, CP932, GB2312, GBK or SJIS. These are blacklisted as they may [introduce a SQL injection vulnerability](http://stackoverflow.com/a/12118602/3430118)!*
-
-##### `loc`
-
-```
-Type:           string
-Valid Values:   <escaped name>
-Default:        UTC
-```
-
-Sets the location for time.Time values (when using `parseTime=true`). *"Local"* sets the system's location. See [time.LoadLocation](https://golang.org/pkg/time/#LoadLocation) for details.
-
-Note that this sets the location for time.Time values but does not change MySQL's [time_zone setting](https://dev.mysql.com/doc/refman/5.5/en/time-zone-support.html). For that see the [time_zone system variable](#system-variables), which can also be set as a DSN parameter.
-
-Please keep in mind, that param values must be [url.QueryEscape](https://golang.org/pkg/net/url/#QueryEscape)'ed. Alternatively you can manually replace the `/` with `%2F`. For example `US/Pacific` would be `loc=US%2FPacific`.
-
-##### `maxAllowedPacket`
-```
-Type:          decimal number
-Default:       4194304
-```
-
-Max packet size allowed in bytes. The default value is 4 MiB and should be adjusted to match the server settings. `maxAllowedPacket=0` can be used to automatically fetch the `max_allowed_packet` variable from server *on every connection*.
-
-##### `multiStatements`
-
-```
-Type:           bool
-Valid Values:   true, false
-Default:        false
-```
-
-Allow multiple statements in one query. While this allows batch queries, it also greatly increases the risk of SQL injections. Only the result of the first query is returned, all other results are silently discarded.
-
-When `multiStatements` is used, `?` parameters must only be used in the first statement.
-
-##### `parseTime`
-
-```
-Type:           bool
-Valid Values:   true, false
-Default:        false
-```
-
-`parseTime=true` changes the output type of `DATE` and `DATETIME` values to `time.Time` instead of `[]byte` / `string`
-The date or datetime like `0000-00-00 00:00:00` is converted into zero value of `time.Time`.
-
-
-##### `readTimeout`
-
-```
-Type:           duration
-Default:        0
-```
-
-I/O read timeout. The value must be a decimal number with a unit suffix (*"ms"*, *"s"*, *"m"*, *"h"*), such as *"30s"*, *"0.5m"* or *"1m30s"*.
-
-##### `rejectReadOnly`
-
-```
-Type:           bool
-Valid Values:   true, false
-Default:        false
-```
-
-
-`rejectReadOnly=true` causes the driver to reject read-only connections. This
-is for a possible race condition during an automatic failover, where the mysql
-client gets connected to a read-only replica after the failover.
-
-Note that this should be a fairly rare case, as an automatic failover normally
-happens when the primary is down, and the race condition shouldn't happen
-unless it comes back up online as soon as the failover is kicked off. On the
-other hand, when this happens, a MySQL application can get stuck on a
-read-only connection until restarted. It is however fairly easy to reproduce,
-for example, using a manual failover on AWS Aurora's MySQL-compatible cluster.
-
-If you are not relying on read-only transactions to reject writes that aren't
-supposed to happen, setting this on some MySQL providers (such as AWS Aurora)
-is safer for failovers.
-
-Note that ERROR 1290 can be returned for a `read-only` server and this option will
-cause a retry for that error. However the same error number is used for some
-other cases. You should ensure your application will never cause an ERROR 1290
-except for `read-only` mode when enabling this option.
-
-
-##### `serverPubKey`
-
-```
-Type:           string
-Valid Values:   <name>
-Default:        none
-```
-
-Server public keys can be registered with [`mysql.RegisterServerPubKey`](https://godoc.org/github.com/go-sql-driver/mysql#RegisterServerPubKey), which can then be used by the assigned name in the DSN.
-Public keys are used to transmit encrypted data, e.g. for authentication.
-If the server's public key is known, it should be set manually to avoid expensive and potentially insecure transmissions of the public key from the server to the client each time it is required.
-
-
-##### `timeout`
-
-```
-Type:           duration
-Default:        OS default
-```
-
-Timeout for establishing connections, aka dial timeout. The value must be a decimal number with a unit suffix (*"ms"*, *"s"*, *"m"*, *"h"*), such as *"30s"*, *"0.5m"* or *"1m30s"*.
-
-
-##### `tls`
-
-```
-Type:           bool / string
-Valid Values:   true, false, skip-verify, preferred, <name>
-Default:        false
-```
-
-`tls=true` enables TLS / SSL encrypted connection to the server. Use `skip-verify` if you want to use a self-signed or invalid certificate (server side) or use `preferred` to use TLS only when advertised by the server. This is similar to `skip-verify`, but additionally allows a fallback to a connection which is not encrypted. Neither `skip-verify` nor `preferred` add any reliable security. You can use a custom TLS config after registering it with [`mysql.RegisterTLSConfig`](https://godoc.org/github.com/go-sql-driver/mysql#RegisterTLSConfig).
-
-
-##### `writeTimeout`
-
-```
-Type:           duration
-Default:        0
-```
-
-I/O write timeout. The value must be a decimal number with a unit suffix (*"ms"*, *"s"*, *"m"*, *"h"*), such as *"30s"*, *"0.5m"* or *"1m30s"*.
-
-
-##### System Variables
-
-Any other parameters are interpreted as system variables:
-  * `<boolean_var>=<value>`: `SET <boolean_var>=<value>`
-  * `<enum_var>=<value>`: `SET <enum_var>=<value>`
-  * `<string_var>=%27<value>%27`: `SET <string_var>='<value>'`
-
-Rules:
-* The values for string variables must be quoted with `'`.
-* The values must also be [url.QueryEscape](http://golang.org/pkg/net/url/#QueryEscape)'ed!
- (which implies values of string variables must be wrapped with `%27`).
-
-Examples:
-  * `autocommit=1`: `SET autocommit=1`
-  * [`time_zone=%27Europe%2FParis%27`](https://dev.mysql.com/doc/refman/5.5/en/time-zone-support.html): `SET time_zone='Europe/Paris'`
-  * [`tx_isolation=%27REPEATABLE-READ%27`](https://dev.mysql.com/doc/refman/5.5/en/server-system-variables.html#sysvar_tx_isolation): `SET tx_isolation='REPEATABLE-READ'`
-
-
-#### Examples
-```
-user@unix(/path/to/socket)/dbname
-```
-
-```
-root:pw@unix(/tmp/mysql.sock)/myDatabase?loc=Local
-```
-
-```
-user:password@tcp(localhost:5555)/dbname?tls=skip-verify&autocommit=true
-```
-
-Treat warnings as errors by setting the system variable [`sql_mode`](https://dev.mysql.com/doc/refman/5.7/en/sql-mode.html):
-```
-user:password@/dbname?sql_mode=TRADITIONAL
-```
-
-TCP via IPv6:
-```
-user:password@tcp([de:ad:be:ef::ca:fe]:80)/dbname?timeout=90s&collation=utf8mb4_unicode_ci
-```
-
-TCP on a remote host, e.g. Amazon RDS:
-```
-id:password@tcp(your-amazonaws-uri.com:3306)/dbname
-```
-
-Google Cloud SQL on App Engine:
-```
-user:password@unix(/cloudsql/project-id:region-name:instance-name)/dbname
-```
-
-TCP using default port (3306) on localhost:
-```
-user:password@tcp/dbname?charset=utf8mb4,utf8&sys_var=esc%40ped
-```
-
-Use the default protocol (tcp) and host (localhost:3306):
-```
-user:password@/dbname
-```
-
-No Database preselected:
-```
-user:password@/
-```
-
-
-### Connection pool and timeouts
-The connection pool is managed by Go's database/sql package. For details on how to configure the size of the pool and how long connections stay in the pool see `*DB.SetMaxOpenConns`, `*DB.SetMaxIdleConns`, and `*DB.SetConnMaxLifetime` in the [database/sql documentation](https://golang.org/pkg/database/sql/). The read, write, and dial timeouts for each individual connection are configured with the DSN parameters [`readTimeout`](#readtimeout), [`writeTimeout`](#writetimeout), and [`timeout`](#timeout), respectively.
-
-## `ColumnType` Support
-This driver supports the [`ColumnType` interface](https://golang.org/pkg/database/sql/#ColumnType) introduced in Go 1.8, with the exception of [`ColumnType.Length()`](https://golang.org/pkg/database/sql/#ColumnType.Length), which is currently not supported.
-
-## `context.Context` Support
-Go 1.8 added `database/sql` support for `context.Context`. This driver supports query timeouts and cancellation via contexts.
-See [context support in the database/sql package](https://golang.org/doc/go1.8#database_sql) for more details.
-
-
-### `LOAD DATA LOCAL INFILE` support
-For this feature you need direct access to the package. Therefore you must change the import path (no `_`):
-```go
-import "github.com/go-sql-driver/mysql"
-```
-
-Files must be whitelisted by registering them with `mysql.RegisterLocalFile(filepath)` (recommended) or the Whitelist check must be deactivated by using the DSN parameter `allowAllFiles=true` ([*Might be insecure!*](http://dev.mysql.com/doc/refman/5.7/en/load-data-local.html)).
-
-To use a `io.Reader` a handler function must be registered with `mysql.RegisterReaderHandler(name, handler)` which returns a `io.Reader` or `io.ReadCloser`. The Reader is available with the filepath `Reader::<name>` then. Choose different names for different handlers and `DeregisterReaderHandler` when you don't need it anymore.
-
-See the [godoc of Go-MySQL-Driver](https://godoc.org/github.com/go-sql-driver/mysql "golang mysql driver documentation") for details.
-
-
-### `time.Time` support
-The default internal output type of MySQL `DATE` and `DATETIME` values is `[]byte` which allows you to scan the value into a `[]byte`, `string` or `sql.RawBytes` variable in your program.
-
-However, many want to scan MySQL `DATE` and `DATETIME` values into `time.Time` variables, which is the logical equivalent in Go to `DATE` and `DATETIME` in MySQL. You can do that by changing the internal output type from `[]byte` to `time.Time` with the DSN parameter `parseTime=true`. You can set the default [`time.Time` location](https://golang.org/pkg/time/#Location) with the `loc` DSN parameter.
-
-**Caution:** As of Go 1.1, this makes `time.Time` the only variable type you can scan `DATE` and `DATETIME` values into. This breaks for example [`sql.RawBytes` support](https://github.com/go-sql-driver/mysql/wiki/Examples#rawbytes).
-
-Alternatively you can use the [`NullTime`](https://godoc.org/github.com/go-sql-driver/mysql#NullTime) type as the scan destination, which works with both `time.Time` and `string` / `[]byte`.
-
-
-### Unicode support
-Since version 1.5 Go-MySQL-Driver automatically uses the collation ` utf8mb4_general_ci` by default.
-
-Other collations / charsets can be set using the [`collation`](#collation) DSN parameter.
-
-Version 1.0 of the driver recommended adding `&charset=utf8` (alias for `SET NAMES utf8`) to the DSN to enable proper UTF-8 support. This is not necessary anymore. The [`collation`](#collation) parameter should be preferred to set another collation / charset than the default.
-
-See http://dev.mysql.com/doc/refman/8.0/en/charset-unicode.html for more details on MySQL's Unicode support.
-
-## Testing / Development
-To run the driver tests you may need to adjust the configuration. See the [Testing Wiki-Page](https://github.com/go-sql-driver/mysql/wiki/Testing "Testing") for details.
-
-Go-MySQL-Driver is not feature-complete yet. Your help is very appreciated.
-If you want to contribute, you can work on an [open issue](https://github.com/go-sql-driver/mysql/issues?state=open) or review a [pull request](https://github.com/go-sql-driver/mysql/pulls).
-
-See the [Contribution Guidelines](https://github.com/go-sql-driver/mysql/blob/master/CONTRIBUTING.md) for details.
-
----------------------------------------
-
-## License
-Go-MySQL-Driver is licensed under the [Mozilla Public License Version 2.0](https://raw.github.com/go-sql-driver/mysql/master/LICENSE)
-
-Mozilla summarizes the license scope as follows:
-> MPL: The copyleft applies to any files containing MPLed code.
-
-
-That means:
-  * You can **use** the **unchanged** source code both in private and commercially.
-  * When distributing, you **must publish** the source code of any **changed files** licensed under the MPL 2.0 under a) the MPL 2.0 itself or b) a compatible license (e.g. GPL 3.0 or Apache License 2.0).
-  * You **needn't publish** the source code of your library as long as the files licensed under the MPL 2.0 are **unchanged**.
-
-Please read the [MPL 2.0 FAQ](https://www.mozilla.org/en-US/MPL/2.0/FAQ/) if you have further questions regarding the license.
-
-You can read the full terms here: [LICENSE](https://raw.github.com/go-sql-driver/mysql/master/LICENSE).
-
-![Go Gopher and MySQL Dolphin](https://raw.github.com/wiki/go-sql-driver/mysql/go-mysql-driver_m.jpg "Golang Gopher transporting the MySQL Dolphin in a wheelbarrow")
-

vendor/github.com/go-sql-driver/mysql/auth.go

@@ -1,422 +0,0 @@
-// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
-//
-// Copyright 2018 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/.
-
-package mysql
-
-import (
-	"crypto/rand"
-	"crypto/rsa"
-	"crypto/sha1"
-	"crypto/sha256"
-	"crypto/x509"
-	"encoding/pem"
-	"sync"
-)
-
-// server pub keys registry
-var (
-	serverPubKeyLock     sync.RWMutex
-	serverPubKeyRegistry map[string]*rsa.PublicKey
-)
-
-// RegisterServerPubKey registers a server RSA public key which can be used to
-// send data in a secure manner to the server without receiving the public key
-// in a potentially insecure way from the server first.
-// Registered keys can afterwards be used adding serverPubKey=<name> to the DSN.
-//
-// Note: The provided rsa.PublicKey instance is exclusively owned by the driver
-// after registering it and may not be modified.
-//
-//  data, err := ioutil.ReadFile("mykey.pem")
-//  if err != nil {
-//  	log.Fatal(err)
-//  }
-//
-//  block, _ := pem.Decode(data)
-//  if block == nil || block.Type != "PUBLIC KEY" {
-//  	log.Fatal("failed to decode PEM block containing public key")
-//  }
-//
-//  pub, err := x509.ParsePKIXPublicKey(block.Bytes)
-//  if err != nil {
-//  	log.Fatal(err)
-//  }
-//
-//  if rsaPubKey, ok := pub.(*rsa.PublicKey); ok {
-//  	mysql.RegisterServerPubKey("mykey", rsaPubKey)
-//  } else {
-//  	log.Fatal("not a RSA public key")
-//  }
-//
-func RegisterServerPubKey(name string, pubKey *rsa.PublicKey) {
-	serverPubKeyLock.Lock()
-	if serverPubKeyRegistry == nil {
-		serverPubKeyRegistry = make(map[string]*rsa.PublicKey)
-	}
-
-	serverPubKeyRegistry[name] = pubKey
-	serverPubKeyLock.Unlock()
-}
-
-// DeregisterServerPubKey removes the public key registered with the given name.
-func DeregisterServerPubKey(name string) {
-	serverPubKeyLock.Lock()
-	if serverPubKeyRegistry != nil {
-		delete(serverPubKeyRegistry, name)
-	}
-	serverPubKeyLock.Unlock()
-}
-
-func getServerPubKey(name string) (pubKey *rsa.PublicKey) {
-	serverPubKeyLock.RLock()
-	if v, ok := serverPubKeyRegistry[name]; ok {
-		pubKey = v
-	}
-	serverPubKeyLock.RUnlock()
-	return
-}
-
-// Hash password using pre 4.1 (old password) method
-// https://github.com/atcurtis/mariadb/blob/master/mysys/my_rnd.c
-type myRnd struct {
-	seed1, seed2 uint32
-}
-
-const myRndMaxVal = 0x3FFFFFFF
-
-// Pseudo random number generator
-func newMyRnd(seed1, seed2 uint32) *myRnd {
-	return &myRnd{
-		seed1: seed1 % myRndMaxVal,
-		seed2: seed2 % myRndMaxVal,
-	}
-}
-
-// Tested to be equivalent to MariaDB's floating point variant
-// http://play.golang.org/p/QHvhd4qved
-// http://play.golang.org/p/RG0q4ElWDx
-func (r *myRnd) NextByte() byte {
-	r.seed1 = (r.seed1*3 + r.seed2) % myRndMaxVal
-	r.seed2 = (r.seed1 + r.seed2 + 33) % myRndMaxVal
-
-	return byte(uint64(r.seed1) * 31 / myRndMaxVal)
-}
-
-// Generate binary hash from byte string using insecure pre 4.1 method
-func pwHash(password []byte) (result [2]uint32) {
-	var add uint32 = 7
-	var tmp uint32
-
-	result[0] = 1345345333
-	result[1] = 0x12345671
-
-	for _, c := range password {
-		// skip spaces and tabs in password
-		if c == ' ' || c == '\t' {
-			continue
-		}
-
-		tmp = uint32(c)
-		result[0] ^= (((result[0] & 63) + add) * tmp) + (result[0] << 8)
-		result[1] += (result[1] << 8) ^ result[0]
-		add += tmp
-	}
-
-	// Remove sign bit (1<<31)-1)
-	result[0] &= 0x7FFFFFFF
-	result[1] &= 0x7FFFFFFF
-
-	return
-}
-
-// Hash password using insecure pre 4.1 method
-func scrambleOldPassword(scramble []byte, password string) []byte {
-	if len(password) == 0 {
-		return nil
-	}
-
-	scramble = scramble[:8]
-
-	hashPw := pwHash([]byte(password))
-	hashSc := pwHash(scramble)
-
-	r := newMyRnd(hashPw[0]^hashSc[0], hashPw[1]^hashSc[1])
-
-	var out [8]byte
-	for i := range out {
-		out[i] = r.NextByte() + 64
-	}
-
-	mask := r.NextByte()
-	for i := range out {
-		out[i] ^= mask
-	}
-
-	return out[:]
-}
-
-// Hash password using 4.1+ method (SHA1)
-func scramblePassword(scramble []byte, password string) []byte {
-	if len(password) == 0 {
-		return nil
-	}
-
-	// stage1Hash = SHA1(password)
-	crypt := sha1.New()
-	crypt.Write([]byte(password))
-	stage1 := crypt.Sum(nil)
-
-	// scrambleHash = SHA1(scramble + SHA1(stage1Hash))
-	// inner Hash
-	crypt.Reset()
-	crypt.Write(stage1)
-	hash := crypt.Sum(nil)
-
-	// outer Hash
-	crypt.Reset()
-	crypt.Write(scramble)
-	crypt.Write(hash)
-	scramble = crypt.Sum(nil)
-
-	// token = scrambleHash XOR stage1Hash
-	for i := range scramble {
-		scramble[i] ^= stage1[i]
-	}
-	return scramble
-}
-
-// Hash password using MySQL 8+ method (SHA256)
-func scrambleSHA256Password(scramble []byte, password string) []byte {
-	if len(password) == 0 {
-		return nil
-	}
-
-	// XOR(SHA256(password), SHA256(SHA256(SHA256(password)), scramble))
-
-	crypt := sha256.New()
-	crypt.Write([]byte(password))
-	message1 := crypt.Sum(nil)
-
-	crypt.Reset()
-	crypt.Write(message1)
-	message1Hash := crypt.Sum(nil)
-
-	crypt.Reset()
-	crypt.Write(message1Hash)
-	crypt.Write(scramble)
-	message2 := crypt.Sum(nil)
-
-	for i := range message1 {
-		message1[i] ^= message2[i]
-	}
-
-	return message1
-}
-
-func encryptPassword(password string, seed []byte, pub *rsa.PublicKey) ([]byte, error) {
-	plain := make([]byte, len(password)+1)
-	copy(plain, password)
-	for i := range plain {
-		j := i % len(seed)
-		plain[i] ^= seed[j]
-	}
-	sha1 := sha1.New()
-	return rsa.EncryptOAEP(sha1, rand.Reader, pub, plain, nil)
-}
-
-func (mc *mysqlConn) sendEncryptedPassword(seed []byte, pub *rsa.PublicKey) error {
-	enc, err := encryptPassword(mc.cfg.Passwd, seed, pub)
-	if err != nil {
-		return err
-	}
-	return mc.writeAuthSwitchPacket(enc)
-}
-
-func (mc *mysqlConn) auth(authData []byte, plugin string) ([]byte, error) {
-	switch plugin {
-	case "caching_sha2_password":
-		authResp := scrambleSHA256Password(authData, mc.cfg.Passwd)
-		return authResp, nil
-
-	case "mysql_old_password":
-		if !mc.cfg.AllowOldPasswords {
-			return nil, ErrOldPassword
-		}
-		// Note: there are edge cases where this should work but doesn't;
-		// this is currently "wontfix":
-		// https://github.com/go-sql-driver/mysql/issues/184
-		authResp := append(scrambleOldPassword(authData[:8], mc.cfg.Passwd), 0)
-		return authResp, nil
-
-	case "mysql_clear_password":
-		if !mc.cfg.AllowCleartextPasswords {
-			return nil, ErrCleartextPassword
-		}
-		// http://dev.mysql.com/doc/refman/5.7/en/cleartext-authentication-plugin.html
-		// http://dev.mysql.com/doc/refman/5.7/en/pam-authentication-plugin.html
-		return append([]byte(mc.cfg.Passwd), 0), nil
-
-	case "mysql_native_password":
-		if !mc.cfg.AllowNativePasswords {
-			return nil, ErrNativePassword
-		}
-		// https://dev.mysql.com/doc/internals/en/secure-password-authentication.html
-		// Native password authentication only need and will need 20-byte challenge.
-		authResp := scramblePassword(authData[:20], mc.cfg.Passwd)
-		return authResp, nil
-
-	case "sha256_password":
-		if len(mc.cfg.Passwd) == 0 {
-			return []byte{0}, nil
-		}
-		if mc.cfg.tls != nil || mc.cfg.Net == "unix" {
-			// write cleartext auth packet
-			return append([]byte(mc.cfg.Passwd), 0), nil
-		}
-
-		pubKey := mc.cfg.pubKey
-		if pubKey == nil {
-			// request public key from server
-			return []byte{1}, nil
-		}
-
-		// encrypted password
-		enc, err := encryptPassword(mc.cfg.Passwd, authData, pubKey)
-		return enc, err
-
-	default:
-		errLog.Print("unknown auth plugin:", plugin)
-		return nil, ErrUnknownPlugin
-	}
-}
-
-func (mc *mysqlConn) handleAuthResult(oldAuthData []byte, plugin string) error {
-	// Read Result Packet
-	authData, newPlugin, err := mc.readAuthResult()
-	if err != nil {
-		return err
-	}
-
-	// handle auth plugin switch, if requested
-	if newPlugin != "" {
-		// If CLIENT_PLUGIN_AUTH capability is not supported, no new cipher is
-		// sent and we have to keep using the cipher sent in the init packet.
-		if authData == nil {
-			authData = oldAuthData
-		} else {
-			// copy data from read buffer to owned slice
-			copy(oldAuthData, authData)
-		}
-
-		plugin = newPlugin
-
-		authResp, err := mc.auth(authData, plugin)
-		if err != nil {
-			return err
-		}
-		if err = mc.writeAuthSwitchPacket(authResp); err != nil {
-			return err
-		}
-
-		// Read Result Packet
-		authData, newPlugin, err = mc.readAuthResult()
-		if err != nil {
-			return err
-		}
-
-		// Do not allow to change the auth plugin more than once
-		if newPlugin != "" {
-			return ErrMalformPkt
-		}
-	}
-
-	switch plugin {
-
-	// https://insidemysql.com/preparing-your-community-connector-for-mysql-8-part-2-sha256/
-	case "caching_sha2_password":
-		switch len(authData) {
-		case 0:
-			return nil // auth successful
-		case 1:
-			switch authData[0] {
-			case cachingSha2PasswordFastAuthSuccess:
-				if err = mc.readResultOK(); err == nil {
-					return nil // auth successful
-				}
-
-			case cachingSha2PasswordPerformFullAuthentication:
-				if mc.cfg.tls != nil || mc.cfg.Net == "unix" {
-					// write cleartext auth packet
-					err = mc.writeAuthSwitchPacket(append([]byte(mc.cfg.Passwd), 0))
-					if err != nil {
-						return err
-					}
-				} else {
-					pubKey := mc.cfg.pubKey
-					if pubKey == nil {
-						// request public key from server
-						data, err := mc.buf.takeSmallBuffer(4 + 1)
-						if err != nil {
-							return err
-						}
-						data[4] = cachingSha2PasswordRequestPublicKey
-						mc.writePacket(data)
-
-						// parse public key
-						if data, err = mc.readPacket(); err != nil {
-							return err
-						}
-
-						block, _ := pem.Decode(data[1:])
-						pkix, err := x509.ParsePKIXPublicKey(block.Bytes)
-						if err != nil {
-							return err
-						}
-						pubKey = pkix.(*rsa.PublicKey)
-					}
-
-					// send encrypted password
-					err = mc.sendEncryptedPassword(oldAuthData, pubKey)
-					if err != nil {
-						return err
-					}
-				}
-				return mc.readResultOK()
-
-			default:
-				return ErrMalformPkt
-			}
-		default:
-			return ErrMalformPkt
-		}
-
-	case "sha256_password":
-		switch len(authData) {
-		case 0:
-			return nil // auth successful
-		default:
-			block, _ := pem.Decode(authData)
-			pub, err := x509.ParsePKIXPublicKey(block.Bytes)
-			if err != nil {
-				return err
-			}
-
-			// send encrypted password
-			err = mc.sendEncryptedPassword(oldAuthData, pub.(*rsa.PublicKey))
-			if err != nil {
-				return err
-			}
-			return mc.readResultOK()
-		}
-
-	default:
-		return nil // auth successful
-	}
-
-	return err
-}

vendor/github.com/go-sql-driver/mysql/buffer.go

@@ -1,182 +0,0 @@
-// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
-//
-// Copyright 2013 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/.
-
-package mysql
-
-import (
-	"io"
-	"net"
-	"time"
-)
-
-const defaultBufSize = 4096
-const maxCachedBufSize = 256 * 1024
-
-// A buffer which is used for both reading and writing.
-// This is possible since communication on each connection is synchronous.
-// In other words, we can't write and read simultaneously on the same connection.
-// The buffer is similar to bufio.Reader / Writer but zero-copy-ish
-// Also highly optimized for this particular use case.
-// This buffer is backed by two byte slices in a double-buffering scheme
-type buffer struct {
-	buf     []byte // buf is a byte buffer who's length and capacity are equal.
-	nc      net.Conn
-	idx     int
-	length  int
-	timeout time.Duration
-	dbuf    [2][]byte // dbuf is an array with the two byte slices that back this buffer
-	flipcnt uint      // flipccnt is the current buffer counter for double-buffering
-}
-
-// newBuffer allocates and returns a new buffer.
-func newBuffer(nc net.Conn) buffer {
-	fg := make([]byte, defaultBufSize)
-	return buffer{
-		buf:  fg,
-		nc:   nc,
-		dbuf: [2][]byte{fg, nil},
-	}
-}
-
-// flip replaces the active buffer with the background buffer
-// this is a delayed flip that simply increases the buffer counter;
-// the actual flip will be performed the next time we call `buffer.fill`
-func (b *buffer) flip() {
-	b.flipcnt += 1
-}
-
-// fill reads into the buffer until at least _need_ bytes are in it
-func (b *buffer) fill(need int) error {
-	n := b.length
-	// fill data into its double-buffering target: if we've called
-	// flip on this buffer, we'll be copying to the background buffer,
-	// and then filling it with network data; otherwise we'll just move
-	// the contents of the current buffer to the front before filling it
-	dest := b.dbuf[b.flipcnt&1]
-
-	// grow buffer if necessary to fit the whole packet.
-	if need > len(dest) {
-		// Round up to the next multiple of the default size
-		dest = make([]byte, ((need/defaultBufSize)+1)*defaultBufSize)
-
-		// if the allocated buffer is not too large, move it to backing storage
-		// to prevent extra allocations on applications that perform large reads
-		if len(dest) <= maxCachedBufSize {
-			b.dbuf[b.flipcnt&1] = dest
-		}
-	}
-
-	// if we're filling the fg buffer, move the existing data to the start of it.
-	// if we're filling the bg buffer, copy over the data
-	if n > 0 {
-		copy(dest[:n], b.buf[b.idx:])
-	}
-
-	b.buf = dest
-	b.idx = 0
-
-	for {
-		if b.timeout > 0 {
-			if err := b.nc.SetReadDeadline(time.Now().Add(b.timeout)); err != nil {
-				return err
-			}
-		}
-
-		nn, err := b.nc.Read(b.buf[n:])
-		n += nn
-
-		switch err {
-		case nil:
-			if n < need {
-				continue
-			}
-			b.length = n
-			return nil
-
-		case io.EOF:
-			if n >= need {
-				b.length = n
-				return nil
-			}
-			return io.ErrUnexpectedEOF
-
-		default:
-			return err
-		}
-	}
-}
-
-// returns next N bytes from buffer.
-// The returned slice is only guaranteed to be valid until the next read
-func (b *buffer) readNext(need int) ([]byte, error) {
-	if b.length < need {
-		// refill
-		if err := b.fill(need); err != nil {
-			return nil, err
-		}
-	}
-
-	offset := b.idx
-	b.idx += need
-	b.length -= need
-	return b.buf[offset:b.idx], nil
-}
-
-// takeBuffer returns a buffer with the requested size.
-// If possible, a slice from the existing buffer is returned.
-// Otherwise a bigger buffer is made.
-// Only one buffer (total) can be used at a time.
-func (b *buffer) takeBuffer(length int) ([]byte, error) {
-	if b.length > 0 {
-		return nil, ErrBusyBuffer
-	}
-
-	// test (cheap) general case first
-	if length <= cap(b.buf) {
-		return b.buf[:length], nil
-	}
-
-	if length < maxPacketSize {
-		b.buf = make([]byte, length)
-		return b.buf, nil
-	}
-
-	// buffer is larger than we want to store.
-	return make([]byte, length), nil
-}
-
-// takeSmallBuffer is shortcut which can be used if length is
-// known to be smaller than defaultBufSize.
-// Only one buffer (total) can be used at a time.
-func (b *buffer) takeSmallBuffer(length int) ([]byte, error) {
-	if b.length > 0 {
-		return nil, ErrBusyBuffer
-	}
-	return b.buf[:length], nil
-}
-
-// takeCompleteBuffer returns the complete existing buffer.
-// This can be used if the necessary buffer size is unknown.
-// cap and len of the returned buffer will be equal.
-// Only one buffer (total) can be used at a time.
-func (b *buffer) takeCompleteBuffer() ([]byte, error) {
-	if b.length > 0 {
-		return nil, ErrBusyBuffer
-	}
-	return b.buf, nil
-}
-
-// store stores buf, an updated buffer, if its suitable to do so.
-func (b *buffer) store(buf []byte) error {
-	if b.length > 0 {
-		return ErrBusyBuffer
-	} else if cap(buf) <= maxPacketSize && cap(buf) > cap(b.buf) {
-		b.buf = buf[:cap(buf)]
-	}
-	return nil
-}

vendor/github.com/go-sql-driver/mysql/collations.go

@@ -1,265 +0,0 @@
-// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
-//
-// Copyright 2014 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/.
-
-package mysql
-
-const defaultCollation = "utf8mb4_general_ci"
-const binaryCollation = "binary"
-
-// A list of available collations mapped to the internal ID.
-// To update this map use the following MySQL query:
-//     SELECT COLLATION_NAME, ID FROM information_schema.COLLATIONS WHERE ID<256 ORDER BY ID
-//
-// Handshake packet have only 1 byte for collation_id.  So we can't use collations with ID > 255.
-//
-// ucs2, utf16, and utf32 can't be used for connection charset.
-// https://dev.mysql.com/doc/refman/5.7/en/charset-connection.html#charset-connection-impermissible-client-charset
-// They are commented out to reduce this map.
-var collations = map[string]byte{
-	"big5_chinese_ci":      1,
-	"latin2_czech_cs":      2,
-	"dec8_swedish_ci":      3,
-	"cp850_general_ci":     4,
-	"latin1_german1_ci":    5,
-	"hp8_english_ci":       6,
-	"koi8r_general_ci":     7,
-	"latin1_swedish_ci":    8,
-	"latin2_general_ci":    9,
-	"swe7_swedish_ci":      10,
-	"ascii_general_ci":     11,
-	"ujis_japanese_ci":     12,
-	"sjis_japanese_ci":     13,
-	"cp1251_bulgarian_ci":  14,
-	"latin1_danish_ci":     15,
-	"hebrew_general_ci":    16,
-	"tis620_thai_ci":       18,
-	"euckr_korean_ci":      19,
-	"latin7_estonian_cs":   20,
-	"latin2_hungarian_ci":  21,
-	"koi8u_general_ci":     22,
-	"cp1251_ukrainian_ci":  23,
-	"gb2312_chinese_ci":    24,
-	"greek_general_ci":     25,
-	"cp1250_general_ci":    26,
-	"latin2_croatian_ci":   27,
-	"gbk_chinese_ci":       28,
-	"cp1257_lithuanian_ci": 29,
-	"latin5_turkish_ci":    30,
-	"latin1_german2_ci":    31,
-	"armscii8_general_ci":  32,
-	"utf8_general_ci":      33,
-	"cp1250_czech_cs":      34,
-	//"ucs2_general_ci":          35,
-	"cp866_general_ci":    36,
-	"keybcs2_general_ci":  37,
-	"macce_general_ci":    38,
-	"macroman_general_ci": 39,
-	"cp852_general_ci":    40,
-	"latin7_general_ci":   41,
-	"latin7_general_cs":   42,
-	"macce_bin":           43,
-	"cp1250_croatian_ci":  44,
-	"utf8mb4_general_ci":  45,
-	"utf8mb4_bin":         46,
-	"latin1_bin":          47,
-	"latin1_general_ci":   48,
-	"latin1_general_cs":   49,
-	"cp1251_bin":          50,
-	"cp1251_general_ci":   51,
-	"cp1251_general_cs":   52,
-	"macroman_bin":        53,
-	//"utf16_general_ci":         54,
-	//"utf16_bin":                55,
-	//"utf16le_general_ci":       56,
-	"cp1256_general_ci": 57,
-	"cp1257_bin":        58,
-	"cp1257_general_ci": 59,
-	//"utf32_general_ci":         60,
-	//"utf32_bin":                61,
-	//"utf16le_bin":              62,
-	"binary":          63,
-	"armscii8_bin":    64,
-	"ascii_bin":       65,
-	"cp1250_bin":      66,
-	"cp1256_bin":      67,
-	"cp866_bin":       68,
-	"dec8_bin":        69,
-	"greek_bin":       70,
-	"hebrew_bin":      71,
-	"hp8_bin":         72,
-	"keybcs2_bin":     73,
-	"koi8r_bin":       74,
-	"koi8u_bin":       75,
-	"utf8_tolower_ci": 76,
-	"latin2_bin":      77,
-	"latin5_bin":      78,
-	"latin7_bin":      79,
-	"cp850_bin":       80,
-	"cp852_bin":       81,
-	"swe7_bin":        82,
-	"utf8_bin":        83,
-	"big5_bin":        84,
-	"euckr_bin":       85,
-	"gb2312_bin":      86,
-	"gbk_bin":         87,
-	"sjis_bin":        88,
-	"tis620_bin":      89,
-	//"ucs2_bin":                 90,
-	"ujis_bin":            91,
-	"geostd8_general_ci":  92,
-	"geostd8_bin":         93,
-	"latin1_spanish_ci":   94,
-	"cp932_japanese_ci":   95,
-	"cp932_bin":           96,
-	"eucjpms_japanese_ci": 97,
-	"eucjpms_bin":         98,
-	"cp1250_polish_ci":    99,
-	//"utf16_unicode_ci":         101,
-	//"utf16_icelandic_ci":       102,
-	//"utf16_latvian_ci":         103,
-	//"utf16_romanian_ci":        104,
-	//"utf16_slovenian_ci":       105,
-	//"utf16_polish_ci":          106,
-	//"utf16_estonian_ci":        107,
-	//"utf16_spanish_ci":         108,
-	//"utf16_swedish_ci":         109,
-	//"utf16_turkish_ci":         110,
-	//"utf16_czech_ci":           111,
-	//"utf16_danish_ci":          112,
-	//"utf16_lithuanian_ci":      113,
-	//"utf16_slovak_ci":          114,
-	//"utf16_spanish2_ci":        115,
-	//"utf16_roman_ci":           116,
-	//"utf16_persian_ci":         117,
-	//"utf16_esperanto_ci":       118,
-	//"utf16_hungarian_ci":       119,
-	//"utf16_sinhala_ci":         120,
-	//"utf16_german2_ci":         121,
-	//"utf16_croatian_ci":        122,
-	//"utf16_unicode_520_ci":     123,
-	//"utf16_vietnamese_ci":      124,
-	//"ucs2_unicode_ci":          128,
-	//"ucs2_icelandic_ci":        129,
-	//"ucs2_latvian_ci":          130,
-	//"ucs2_romanian_ci":         131,
-	//"ucs2_slovenian_ci":        132,
-	//"ucs2_polish_ci":           133,
-	//"ucs2_estonian_ci":         134,
-	//"ucs2_spanish_ci":          135,
-	//"ucs2_swedish_ci":          136,
-	//"ucs2_turkish_ci":          137,
-	//"ucs2_czech_ci":            138,
-	//"ucs2_danish_ci":           139,
-	//"ucs2_lithuanian_ci":       140,
-	//"ucs2_slovak_ci":           141,
-	//"ucs2_spanish2_ci":         142,
-	//"ucs2_roman_ci":            143,
-	//"ucs2_persian_ci":          144,
-	//"ucs2_esperanto_ci":        145,
-	//"ucs2_hungarian_ci":        146,
-	//"ucs2_sinhala_ci":          147,
-	//"ucs2_german2_ci":          148,
-	//"ucs2_croatian_ci":         149,
-	//"ucs2_unicode_520_ci":      150,
-	//"ucs2_vietnamese_ci":       151,
-	//"ucs2_general_mysql500_ci": 159,
-	//"utf32_unicode_ci":         160,
-	//"utf32_icelandic_ci":       161,
-	//"utf32_latvian_ci":         162,
-	//"utf32_romanian_ci":        163,
-	//"utf32_slovenian_ci":       164,
-	//"utf32_polish_ci":          165,
-	//"utf32_estonian_ci":        166,
-	//"utf32_spanish_ci":         167,
-	//"utf32_swedish_ci":         168,
-	//"utf32_turkish_ci":         169,
-	//"utf32_czech_ci":           170,
-	//"utf32_danish_ci":          171,
-	//"utf32_lithuanian_ci":      172,
-	//"utf32_slovak_ci":          173,
-	//"utf32_spanish2_ci":        174,
-	//"utf32_roman_ci":           175,
-	//"utf32_persian_ci":         176,
-	//"utf32_esperanto_ci":       177,
-	//"utf32_hungarian_ci":       178,
-	//"utf32_sinhala_ci":         179,
-	//"utf32_german2_ci":         180,
-	//"utf32_croatian_ci":        181,
-	//"utf32_unicode_520_ci":     182,
-	//"utf32_vietnamese_ci":      183,
-	"utf8_unicode_ci":          192,
-	"utf8_icelandic_ci":        193,
-	"utf8_latvian_ci":          194,
-	"utf8_romanian_ci":         195,
-	"utf8_slovenian_ci":        196,
-	"utf8_polish_ci":           197,
-	"utf8_estonian_ci":         198,
-	"utf8_spanish_ci":          199,
-	"utf8_swedish_ci":          200,
-	"utf8_turkish_ci":          201,
-	"utf8_czech_ci":            202,
-	"utf8_danish_ci":           203,
-	"utf8_lithuanian_ci":       204,
-	"utf8_slovak_ci":           205,
-	"utf8_spanish2_ci":         206,
-	"utf8_roman_ci":            207,
-	"utf8_persian_ci":          208,
-	"utf8_esperanto_ci":        209,
-	"utf8_hungarian_ci":        210,
-	"utf8_sinhala_ci":          211,
-	"utf8_german2_ci":          212,
-	"utf8_croatian_ci":         213,
-	"utf8_unicode_520_ci":      214,
-	"utf8_vietnamese_ci":       215,
-	"utf8_general_mysql500_ci": 223,
-	"utf8mb4_unicode_ci":       224,
-	"utf8mb4_icelandic_ci":     225,
-	"utf8mb4_latvian_ci":       226,
-	"utf8mb4_romanian_ci":      227,
-	"utf8mb4_slovenian_ci":     228,
-	"utf8mb4_polish_ci":        229,
-	"utf8mb4_estonian_ci":      230,
-	"utf8mb4_spanish_ci":       231,
-	"utf8mb4_swedish_ci":       232,
-	"utf8mb4_turkish_ci":       233,
-	"utf8mb4_czech_ci":         234,
-	"utf8mb4_danish_ci":        235,
-	"utf8mb4_lithuanian_ci":    236,
-	"utf8mb4_slovak_ci":        237,
-	"utf8mb4_spanish2_ci":      238,
-	"utf8mb4_roman_ci":         239,
-	"utf8mb4_persian_ci":       240,
-	"utf8mb4_esperanto_ci":     241,
-	"utf8mb4_hungarian_ci":     242,
-	"utf8mb4_sinhala_ci":       243,
-	"utf8mb4_german2_ci":       244,
-	"utf8mb4_croatian_ci":      245,
-	"utf8mb4_unicode_520_ci":   246,
-	"utf8mb4_vietnamese_ci":    247,
-	"gb18030_chinese_ci":       248,
-	"gb18030_bin":              249,
-	"gb18030_unicode_520_ci":   250,
-	"utf8mb4_0900_ai_ci":       255,
-}
-
-// A blacklist of collations which is unsafe to interpolate parameters.
-// These multibyte encodings may contains 0x5c (`\`) in their trailing bytes.
-var unsafeCollations = map[string]bool{
-	"big5_chinese_ci":        true,
-	"sjis_japanese_ci":       true,
-	"gbk_chinese_ci":         true,
-	"big5_bin":               true,
-	"gb2312_bin":             true,
-	"gbk_bin":                true,
-	"sjis_bin":               true,
-	"cp932_japanese_ci":      true,
-	"cp932_bin":              true,
-	"gb18030_chinese_ci":     true,
-	"gb18030_bin":            true,
-	"gb18030_unicode_520_ci": true,
-}

vendor/github.com/go-sql-driver/mysql/conncheck.go

@@ -1,54 +0,0 @@
-// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
-//
-// Copyright 2019 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 linux darwin dragonfly freebsd netbsd openbsd solaris illumos
-
-package mysql
-
-import (
-	"errors"
-	"io"
-	"net"
-	"syscall"
-)
-
-var errUnexpectedRead = errors.New("unexpected read from socket")
-
-func connCheck(conn net.Conn) error {
-	var sysErr error
-
-	sysConn, ok := conn.(syscall.Conn)
-	if !ok {
-		return nil
-	}
-	rawConn, err := sysConn.SyscallConn()
-	if err != nil {
-		return err
-	}
-
-	err = rawConn.Read(func(fd uintptr) bool {
-		var buf [1]byte
-		n, err := syscall.Read(int(fd), buf[:])
-		switch {
-		case n == 0 && err == nil:
-			sysErr = io.EOF
-		case n > 0:
-			sysErr = errUnexpectedRead
-		case err == syscall.EAGAIN || err == syscall.EWOULDBLOCK:
-			sysErr = nil
-		default:
-			sysErr = err
-		}
-		return true
-	})
-	if err != nil {
-		return err
-	}
-
-	return sysErr
-}

vendor/github.com/go-sql-driver/mysql/conncheck_dummy.go

@@ -1,17 +0,0 @@
-// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
-//
-// Copyright 2019 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 !linux,!darwin,!dragonfly,!freebsd,!netbsd,!openbsd,!solaris,!illumos
-
-package mysql
-
-import "net"
-
-func connCheck(conn net.Conn) error {
-	return nil
-}

vendor/github.com/go-sql-driver/mysql/connection.go

@@ -1,651 +0,0 @@
-// 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/.
-
-package mysql
-
-import (
-	"context"
-	"database/sql"
-	"database/sql/driver"
-	"io"
-	"net"
-	"strconv"
-	"strings"
-	"time"
-)
-
-type mysqlConn struct {
-	buf              buffer
-	netConn          net.Conn
-	rawConn          net.Conn // underlying connection when netConn is TLS connection.
-	affectedRows     uint64
-	insertId         uint64
-	cfg              *Config
-	maxAllowedPacket int
-	maxWriteSize     int
-	writeTimeout     time.Duration
-	flags            clientFlag
-	status           statusFlag
-	sequence         uint8
-	parseTime        bool
-	reset            bool // set when the Go SQL package calls ResetSession
-
-	// for context support (Go 1.8+)
-	watching bool
-	watcher  chan<- context.Context
-	closech  chan struct{}
-	finished chan<- struct{}
-	canceled atomicError // set non-nil if conn is canceled
-	closed   atomicBool  // set when conn is closed, before closech is closed
-}
-
-// Handles parameters set in DSN after the connection is established
-func (mc *mysqlConn) handleParams() (err error) {
-	for param, val := range mc.cfg.Params {
-		switch param {
-		// Charset
-		case "charset":
-			charsets := strings.Split(val, ",")
-			for i := range charsets {
-				// ignore errors here - a charset may not exist
-				err = mc.exec("SET NAMES " + charsets[i])
-				if err == nil {
-					break
-				}
-			}
-			if err != nil {
-				return
-			}
-
-		// System Vars
-		default:
-			err = mc.exec("SET " + param + "=" + val + "")
-			if err != nil {
-				return
-			}
-		}
-	}
-
-	return
-}
-
-func (mc *mysqlConn) markBadConn(err error) error {
-	if mc == nil {
-		return err
-	}
-	if err != errBadConnNoWrite {
-		return err
-	}
-	return driver.ErrBadConn
-}
-
-func (mc *mysqlConn) Begin() (driver.Tx, error) {
-	return mc.begin(false)
-}
-
-func (mc *mysqlConn) begin(readOnly bool) (driver.Tx, error) {
-	if mc.closed.IsSet() {
-		errLog.Print(ErrInvalidConn)
-		return nil, driver.ErrBadConn
-	}
-	var q string
-	if readOnly {
-		q = "START TRANSACTION READ ONLY"
-	} else {
-		q = "START TRANSACTION"
-	}
-	err := mc.exec(q)
-	if err == nil {
-		return &mysqlTx{mc}, err
-	}
-	return nil, mc.markBadConn(err)
-}
-
-func (mc *mysqlConn) Close() (err error) {
-	// Makes Close idempotent
-	if !mc.closed.IsSet() {
-		err = mc.writeCommandPacket(comQuit)
-	}
-
-	mc.cleanup()
-
-	return
-}
-
-// Closes the network connection and unsets internal variables. Do not call this
-// function after successfully authentication, call Close instead. This function
-// is called before auth or on auth failure because MySQL will have already
-// closed the network connection.
-func (mc *mysqlConn) cleanup() {
-	if !mc.closed.TrySet(true) {
-		return
-	}
-
-	// Makes cleanup idempotent
-	close(mc.closech)
-	if mc.netConn == nil {
-		return
-	}
-	if err := mc.netConn.Close(); err != nil {
-		errLog.Print(err)
-	}
-}
-
-func (mc *mysqlConn) error() error {
-	if mc.closed.IsSet() {
-		if err := mc.canceled.Value(); err != nil {
-			return err
-		}
-		return ErrInvalidConn
-	}
-	return nil
-}
-
-func (mc *mysqlConn) Prepare(query string) (driver.Stmt, error) {
-	if mc.closed.IsSet() {
-		errLog.Print(ErrInvalidConn)
-		return nil, driver.ErrBadConn
-	}
-	// Send command
-	err := mc.writeCommandPacketStr(comStmtPrepare, query)
-	if err != nil {
-		// STMT_PREPARE is safe to retry.  So we can return ErrBadConn here.
-		errLog.Print(err)
-		return nil, driver.ErrBadConn
-	}
-
-	stmt := &mysqlStmt{
-		mc: mc,
-	}
-
-	// Read Result
-	columnCount, err := stmt.readPrepareResultPacket()
-	if err == nil {
-		if stmt.paramCount > 0 {
-			if err = mc.readUntilEOF(); err != nil {
-				return nil, err
-			}
-		}
-
-		if columnCount > 0 {
-			err = mc.readUntilEOF()
-		}
-	}
-
-	return stmt, err
-}
-
-func (mc *mysqlConn) interpolateParams(query string, args []driver.Value) (string, error) {
-	// Number of ? should be same to len(args)
-	if strings.Count(query, "?") != len(args) {
-		return "", driver.ErrSkip
-	}
-
-	buf, err := mc.buf.takeCompleteBuffer()
-	if err != nil {
-		// can not take the buffer. Something must be wrong with the connection
-		errLog.Print(err)
-		return "", ErrInvalidConn
-	}
-	buf = buf[:0]
-	argPos := 0
-
-	for i := 0; i < len(query); i++ {
-		q := strings.IndexByte(query[i:], '?')
-		if q == -1 {
-			buf = append(buf, query[i:]...)
-			break
-		}
-		buf = append(buf, query[i:i+q]...)
-		i += q
-
-		arg := args[argPos]
-		argPos++
-
-		if arg == nil {
-			buf = append(buf, "NULL"...)
-			continue
-		}
-
-		switch v := arg.(type) {
-		case int64:
-			buf = strconv.AppendInt(buf, v, 10)
-		case uint64:
-			// Handle uint64 explicitly because our custom ConvertValue emits unsigned values
-			buf = strconv.AppendUint(buf, v, 10)
-		case float64:
-			buf = strconv.AppendFloat(buf, v, 'g', -1, 64)
-		case bool:
-			if v {
-				buf = append(buf, '1')
-			} else {
-				buf = append(buf, '0')
-			}
-		case time.Time:
-			if v.IsZero() {
-				buf = append(buf, "'0000-00-00'"...)
-			} else {
-				v := v.In(mc.cfg.Loc)
-				v = v.Add(time.Nanosecond * 500) // To round under microsecond
-				year := v.Year()
-				year100 := year / 100
-				year1 := year % 100
-				month := v.Month()
-				day := v.Day()
-				hour := v.Hour()
-				minute := v.Minute()
-				second := v.Second()
-				micro := v.Nanosecond() / 1000
-
-				buf = append(buf, []byte{
-					'\'',
-					digits10[year100], digits01[year100],
-					digits10[year1], digits01[year1],
-					'-',
-					digits10[month], digits01[month],
-					'-',
-					digits10[day], digits01[day],
-					' ',
-					digits10[hour], digits01[hour],
-					':',
-					digits10[minute], digits01[minute],
-					':',
-					digits10[second], digits01[second],
-				}...)
-
-				if micro != 0 {
-					micro10000 := micro / 10000
-					micro100 := micro / 100 % 100
-					micro1 := micro % 100
-					buf = append(buf, []byte{
-						'.',
-						digits10[micro10000], digits01[micro10000],
-						digits10[micro100], digits01[micro100],
-						digits10[micro1], digits01[micro1],
-					}...)
-				}
-				buf = append(buf, '\'')
-			}
-		case []byte:
-			if v == nil {
-				buf = append(buf, "NULL"...)
-			} else {
-				buf = append(buf, "_binary'"...)
-				if mc.status&statusNoBackslashEscapes == 0 {
-					buf = escapeBytesBackslash(buf, v)
-				} else {
-					buf = escapeBytesQuotes(buf, v)
-				}
-				buf = append(buf, '\'')
-			}
-		case string:
-			buf = append(buf, '\'')
-			if mc.status&statusNoBackslashEscapes == 0 {
-				buf = escapeStringBackslash(buf, v)
-			} else {
-				buf = escapeStringQuotes(buf, v)
-			}
-			buf = append(buf, '\'')
-		default:
-			return "", driver.ErrSkip
-		}
-
-		if len(buf)+4 > mc.maxAllowedPacket {
-			return "", driver.ErrSkip
-		}
-	}
-	if argPos != len(args) {
-		return "", driver.ErrSkip
-	}
-	return string(buf), nil
-}
-
-func (mc *mysqlConn) Exec(query string, args []driver.Value) (driver.Result, error) {
-	if mc.closed.IsSet() {
-		errLog.Print(ErrInvalidConn)
-		return nil, driver.ErrBadConn
-	}
-	if len(args) != 0 {
-		if !mc.cfg.InterpolateParams {
-			return nil, driver.ErrSkip
-		}
-		// try to interpolate the parameters to save extra roundtrips for preparing and closing a statement
-		prepared, err := mc.interpolateParams(query, args)
-		if err != nil {
-			return nil, err
-		}
-		query = prepared
-	}
-	mc.affectedRows = 0
-	mc.insertId = 0
-
-	err := mc.exec(query)
-	if err == nil {
-		return &mysqlResult{
-			affectedRows: int64(mc.affectedRows),
-			insertId:     int64(mc.insertId),
-		}, err
-	}
-	return nil, mc.markBadConn(err)
-}
-
-// Internal function to execute commands
-func (mc *mysqlConn) exec(query string) error {
-	// Send command
-	if err := mc.writeCommandPacketStr(comQuery, query); err != nil {
-		return mc.markBadConn(err)
-	}
-
-	// Read Result
-	resLen, err := mc.readResultSetHeaderPacket()
-	if err != nil {
-		return err
-	}
-
-	if resLen > 0 {
-		// columns
-		if err := mc.readUntilEOF(); err != nil {
-			return err
-		}
-
-		// rows
-		if err := mc.readUntilEOF(); err != nil {
-			return err
-		}
-	}
-
-	return mc.discardResults()
-}
-
-func (mc *mysqlConn) Query(query string, args []driver.Value) (driver.Rows, error) {
-	return mc.query(query, args)
-}
-
-func (mc *mysqlConn) query(query string, args []driver.Value) (*textRows, error) {
-	if mc.closed.IsSet() {
-		errLog.Print(ErrInvalidConn)
-		return nil, driver.ErrBadConn
-	}
-	if len(args) != 0 {
-		if !mc.cfg.InterpolateParams {
-			return nil, driver.ErrSkip
-		}
-		// try client-side prepare to reduce roundtrip
-		prepared, err := mc.interpolateParams(query, args)
-		if err != nil {
-			return nil, err
-		}
-		query = prepared
-	}
-	// Send command
-	err := mc.writeCommandPacketStr(comQuery, query)
-	if err == nil {
-		// Read Result
-		var resLen int
-		resLen, err = mc.readResultSetHeaderPacket()
-		if err == nil {
-			rows := new(textRows)
-			rows.mc = mc
-
-			if resLen == 0 {
-				rows.rs.done = true
-
-				switch err := rows.NextResultSet(); err {
-				case nil, io.EOF:
-					return rows, nil
-				default:
-					return nil, err
-				}
-			}
-
-			// Columns
-			rows.rs.columns, err = mc.readColumns(resLen)
-			return rows, err
-		}
-	}
-	return nil, mc.markBadConn(err)
-}
-
-// Gets the value of the given MySQL System Variable
-// The returned byte slice is only valid until the next read
-func (mc *mysqlConn) getSystemVar(name string) ([]byte, error) {
-	// Send command
-	if err := mc.writeCommandPacketStr(comQuery, "SELECT @@"+name); err != nil {
-		return nil, err
-	}
-
-	// Read Result
-	resLen, err := mc.readResultSetHeaderPacket()
-	if err == nil {
-		rows := new(textRows)
-		rows.mc = mc
-		rows.rs.columns = []mysqlField{{fieldType: fieldTypeVarChar}}
-
-		if resLen > 0 {
-			// Columns
-			if err := mc.readUntilEOF(); err != nil {
-				return nil, err
-			}
-		}
-
-		dest := make([]driver.Value, resLen)
-		if err = rows.readRow(dest); err == nil {
-			return dest[0].([]byte), mc.readUntilEOF()
-		}
-	}
-	return nil, err
-}
-
-// finish is called when the query has canceled.
-func (mc *mysqlConn) cancel(err error) {
-	mc.canceled.Set(err)
-	mc.cleanup()
-}
-
-// finish is called when the query has succeeded.
-func (mc *mysqlConn) finish() {
-	if !mc.watching || mc.finished == nil {
-		return
-	}
-	select {
-	case mc.finished <- struct{}{}:
-		mc.watching = false
-	case <-mc.closech:
-	}
-}
-
-// 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 mc.markBadConn(err)
-	}
-
-	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 context.Context, 1)
-	mc.watcher = watcher
-	finished := make(chan struct{})
-	mc.finished = finished
-	go func() {
-		for {
-			var ctx context.Context
-			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
-	}
-	mc.reset = true
-	return nil
-}

vendor/github.com/go-sql-driver/mysql/connector.go

@@ -1,146 +0,0 @@
-// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
-//
-// Copyright 2018 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/.
-
-package mysql
-
-import (
-	"context"
-	"database/sql/driver"
-	"net"
-)
-
-type connector struct {
-	cfg *Config // immutable private copy.
-}
-
-// Connect implements driver.Connector interface.
-// Connect returns a connection to the database.
-func (c *connector) Connect(ctx context.Context) (driver.Conn, error) {
-	var err error
-
-	// New mysqlConn
-	mc := &mysqlConn{
-		maxAllowedPacket: maxPacketSize,
-		maxWriteSize:     maxPacketSize - 1,
-		closech:          make(chan struct{}),
-		cfg:              c.cfg,
-	}
-	mc.parseTime = mc.cfg.ParseTime
-
-	// Connect to Server
-	dialsLock.RLock()
-	dial, ok := dials[mc.cfg.Net]
-	dialsLock.RUnlock()
-	if ok {
-		dctx := ctx
-		if mc.cfg.Timeout > 0 {
-			var cancel context.CancelFunc
-			dctx, cancel = context.WithTimeout(ctx, c.cfg.Timeout)
-			defer cancel()
-		}
-		mc.netConn, err = dial(dctx, mc.cfg.Addr)
-	} else {
-		nd := net.Dialer{Timeout: mc.cfg.Timeout}
-		mc.netConn, err = nd.DialContext(ctx, mc.cfg.Net, mc.cfg.Addr)
-	}
-
-	if err != nil {
-		return nil, err
-	}
-
-	// Enable TCP Keepalives on TCP connections
-	if tc, ok := mc.netConn.(*net.TCPConn); ok {
-		if err := tc.SetKeepAlive(true); err != nil {
-			// Don't send COM_QUIT before handshake.
-			mc.netConn.Close()
-			mc.netConn = nil
-			return nil, err
-		}
-	}
-
-	// Call startWatcher for context support (From Go 1.8)
-	mc.startWatcher()
-	if err := mc.watchCancel(ctx); err != nil {
-		mc.cleanup()
-		return nil, err
-	}
-	defer mc.finish()
-
-	mc.buf = newBuffer(mc.netConn)
-
-	// Set I/O timeouts
-	mc.buf.timeout = mc.cfg.ReadTimeout
-	mc.writeTimeout = mc.cfg.WriteTimeout
-
-	// Reading Handshake Initialization Packet
-	authData, plugin, err := mc.readHandshakePacket()
-	if err != nil {
-		mc.cleanup()
-		return nil, err
-	}
-
-	if plugin == "" {
-		plugin = defaultAuthPlugin
-	}
-
-	// Send Client Authentication Packet
-	authResp, err := mc.auth(authData, plugin)
-	if err != nil {
-		// try the default auth plugin, if using the requested plugin failed
-		errLog.Print("could not use requested auth plugin '"+plugin+"': ", err.Error())
-		plugin = defaultAuthPlugin
-		authResp, err = mc.auth(authData, plugin)
-		if err != nil {
-			mc.cleanup()
-			return nil, err
-		}
-	}
-	if err = mc.writeHandshakeResponsePacket(authResp, plugin); err != nil {
-		mc.cleanup()
-		return nil, err
-	}
-
-	// Handle response to auth packet, switch methods if possible
-	if err = mc.handleAuthResult(authData, plugin); err != nil {
-		// Authentication failed and MySQL has already closed the connection
-		// (https://dev.mysql.com/doc/internals/en/authentication-fails.html).
-		// Do not send COM_QUIT, just cleanup and return the error.
-		mc.cleanup()
-		return nil, err
-	}
-
-	if mc.cfg.MaxAllowedPacket > 0 {
-		mc.maxAllowedPacket = mc.cfg.MaxAllowedPacket
-	} else {
-		// Get max allowed packet size
-		maxap, err := mc.getSystemVar("max_allowed_packet")
-		if err != nil {
-			mc.Close()
-			return nil, err
-		}
-		mc.maxAllowedPacket = stringToInt(maxap) - 1
-	}
-	if mc.maxAllowedPacket < maxPacketSize {
-		mc.maxWriteSize = mc.maxAllowedPacket
-	}
-
-	// Handle DSN Params
-	err = mc.handleParams()
-	if err != nil {
-		mc.Close()
-		return nil, err
-	}
-
-	return mc, nil
-}
-
-// Driver implements driver.Connector interface.
-// Driver returns &MySQLDriver{}.
-func (c *connector) Driver() driver.Driver {
-	return &MySQLDriver{}
-}

vendor/github.com/go-sql-driver/mysql/const.go

@@ -1,174 +0,0 @@
-// 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/.
-
-package mysql
-
-const (
-	defaultAuthPlugin       = "mysql_native_password"
-	defaultMaxAllowedPacket = 4 << 20 // 4 MiB
-	minProtocolVersion      = 10
-	maxPacketSize           = 1<<24 - 1
-	timeFormat              = "2006-01-02 15:04:05.999999"
-)
-
-// MySQL constants documentation:
-// http://dev.mysql.com/doc/internals/en/client-server-protocol.html
-
-const (
-	iOK           byte = 0x00
-	iAuthMoreData byte = 0x01
-	iLocalInFile  byte = 0xfb
-	iEOF          byte = 0xfe
-	iERR          byte = 0xff
-)
-
-// https://dev.mysql.com/doc/internals/en/capability-flags.html#packet-Protocol::CapabilityFlags
-type clientFlag uint32
-
-const (
-	clientLongPassword clientFlag = 1 << iota
-	clientFoundRows
-	clientLongFlag
-	clientConnectWithDB
-	clientNoSchema
-	clientCompress
-	clientODBC
-	clientLocalFiles
-	clientIgnoreSpace
-	clientProtocol41
-	clientInteractive
-	clientSSL
-	clientIgnoreSIGPIPE
-	clientTransactions
-	clientReserved
-	clientSecureConn
-	clientMultiStatements
-	clientMultiResults
-	clientPSMultiResults
-	clientPluginAuth
-	clientConnectAttrs
-	clientPluginAuthLenEncClientData
-	clientCanHandleExpiredPasswords
-	clientSessionTrack
-	clientDeprecateEOF
-)
-
-const (
-	comQuit byte = iota + 1
-	comInitDB
-	comQuery
-	comFieldList
-	comCreateDB
-	comDropDB
-	comRefresh
-	comShutdown
-	comStatistics
-	comProcessInfo
-	comConnect
-	comProcessKill
-	comDebug
-	comPing
-	comTime
-	comDelayedInsert
-	comChangeUser
-	comBinlogDump
-	comTableDump
-	comConnectOut
-	comRegisterSlave
-	comStmtPrepare
-	comStmtExecute
-	comStmtSendLongData
-	comStmtClose
-	comStmtReset
-	comSetOption
-	comStmtFetch
-)
-
-// https://dev.mysql.com/doc/internals/en/com-query-response.html#packet-Protocol::ColumnType
-type fieldType byte
-
-const (
-	fieldTypeDecimal fieldType = iota
-	fieldTypeTiny
-	fieldTypeShort
-	fieldTypeLong
-	fieldTypeFloat
-	fieldTypeDouble
-	fieldTypeNULL
-	fieldTypeTimestamp
-	fieldTypeLongLong
-	fieldTypeInt24
-	fieldTypeDate
-	fieldTypeTime
-	fieldTypeDateTime
-	fieldTypeYear
-	fieldTypeNewDate
-	fieldTypeVarChar
-	fieldTypeBit
-)
-const (
-	fieldTypeJSON fieldType = iota + 0xf5
-	fieldTypeNewDecimal
-	fieldTypeEnum
-	fieldTypeSet
-	fieldTypeTinyBLOB
-	fieldTypeMediumBLOB
-	fieldTypeLongBLOB
-	fieldTypeBLOB
-	fieldTypeVarString
-	fieldTypeString
-	fieldTypeGeometry
-)
-
-type fieldFlag uint16
-
-const (
-	flagNotNULL fieldFlag = 1 << iota
-	flagPriKey
-	flagUniqueKey
-	flagMultipleKey
-	flagBLOB
-	flagUnsigned
-	flagZeroFill
-	flagBinary
-	flagEnum
-	flagAutoIncrement
-	flagTimestamp
-	flagSet
-	flagUnknown1
-	flagUnknown2
-	flagUnknown3
-	flagUnknown4
-)
-
-// http://dev.mysql.com/doc/internals/en/status-flags.html
-type statusFlag uint16
-
-const (
-	statusInTrans statusFlag = 1 << iota
-	statusInAutocommit
-	statusReserved // Not in documentation
-	statusMoreResultsExists
-	statusNoGoodIndexUsed
-	statusNoIndexUsed
-	statusCursorExists
-	statusLastRowSent
-	statusDbDropped
-	statusNoBackslashEscapes
-	statusMetadataChanged
-	statusQueryWasSlow
-	statusPsOutParams
-	statusInTransReadonly
-	statusSessionStateChanged
-)
-
-const (
-	cachingSha2PasswordRequestPublicKey          = 2
-	cachingSha2PasswordFastAuthSuccess           = 3
-	cachingSha2PasswordPerformFullAuthentication = 4
-)