close_issue_1
/
shop
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[FIX]优化配置读取

This commit is contained in:
viletyy 2020-09-26 14:29:52 +08:00
parent 5010beb901
commit 2095dca48e
10 changed files with 216 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
main.go
View File

@ -2,21 +2,39 @@ package main
import (
"fmt"
"github.com/gin-gonic/gin"
"github.com/go-pripro/shop/models"
"github.com/go-pripro/shop/pkg/logging"
"github.com/go-pripro/shop/pkg/setting"
"github.com/go-pripro/shop/routers"
"log"
"net/http"
)
func main() {
router := routers.InitRouter()
func init() {
setting.Setup()
models.Setup()
logging.Setup()
}
func main() {
gin.SetMode(setting.ServerSetting.RunMode)
routersInit := routers.InitRouter()
readTimeout := setting.ServerSetting.ReadTimeout
writeTimeout := setting.ServerSetting.WriteTimeout
endPoint := fmt.Sprintf(":%d", setting.ServerSetting.HttpPort)
maxHeaderBytes := 1 << 20
s := &http.Server{
Addr: fmt.Sprintf(":%d", setting.HTTPPort),
Handler: router,
ReadTimeout: setting.ReadTimeout,
WriteTimeout: setting.WriteTimeout,
MaxHeaderBytes: 1 << 20,
Addr: endPoint,
Handler: routersInit,
ReadTimeout: readTimeout,
WriteTimeout: writeTimeout,
MaxHeaderBytes: maxHeaderBytes,
}
log.Printf("[info] start http server listening %s", endPoint)
s.ListenAndServe()
}
}

36
models/models.go
View File

@ -18,38 +18,22 @@ type Model struct {
DeleteOn int `json:"deleted_on"`
}
func init() {
var (
err error
dbType, dbName, user, password, host, port, tablePrefix string
)
func Setup() {
var err error
sec, err := setting.Cfg.GetSection("database")
if err != nil {
log.Fatal(2, "Fail to get section 'database': %v", err)
}
dbType = sec.Key("Type").String()
dbName = sec.Key("Name").String()
user = sec.Key("User").String()
password = sec.Key("Password").String()
host = sec.Key("Host").String()
port = sec.Key("Port").String()
tablePrefix = sec.Key("TablePrefix").String()
db, err = gorm.Open(dbType, fmt.Sprintf("host=%s user=%s dbname=%s port=%s sslmode=disable password=%s",
host,
user,
dbName,
port,
password))
db, err = gorm.Open(setting.DatabaseSetting.Type, fmt.Sprintf("host=%s user=%s dbname=%s port=%s sslmode=disable password=%s",
setting.DatabaseSetting.Host,
setting.DatabaseSetting.User,
setting.DatabaseSetting.Name,
setting.DatabaseSetting.Port,
setting.DatabaseSetting.Password))
if err != nil {
log.Println(err)
log.Fatalf("models.Setup err: %v", err)
}
gorm.DefaultTableNameHandler = func(db *gorm.DB, defaultTableName string) string {
return tablePrefix + defaultTableName
return setting.DatabaseSetting.TablePrefix + defaultTableName
}
db.AutoMigrate(&Employee{})

92
pkg/file/file.go Normal file
View File

@ -0,0 +1,92 @@
package file
import (
"fmt"
"io/ioutil"
"mime/multipart"
"os"
"path"
)
// GetSize get the file size 获取文件大小
func GetSize(f multipart.File) (int, error) {
content, err := ioutil.ReadAll(f)
return len(content), err
}
// GetExt get the file ext 获取文件后缀
func GetExt(fileName string) string {
return path.Ext(fileName)
}
// CheckNotExist check if the file exists 检查文件是否存在
func CheckNotExist(src string) bool {
_, err := os.Stat(src)
return os.IsNotExist(err)
}
// CheckPermission check if the file has permission 检查文件权限
func CheckPermission(src string) bool {
_, err := os.Stat(src)
return os.IsPermission(err)
}
// IsNotExistMkDir create a directory if it does not exist 如果不存在则新建文件夹
func IsNotExistMkDir(src string) error {
if notExist := CheckNotExist(src); notExist == true {
if err := MkDir(src); err != nil {
return err
}
}
return nil
}
// MkDir create a directory 新建文件夹
func MkDir(src string) error {
err := os.MkdirAll(src, os.ModePerm)
if err != nil {
return err
}
return nil
}
// Open a file according to a specific mode 打开文件
func Open(name string, flag int, perm os.FileMode) (*os.File, error) {
f, err := os.OpenFile(name, flag, perm)
if err != nil {
return nil, err
}
return f, nil
}
// MustOpen maximize trying to open the file
func MustOpen(fileName, filePath string) (*os.File, error) {
dir, err := os.Getwd()
if err != nil {
return nil, fmt.Errorf("os.Getwd err: %v", err)
}
src := dir + "/" + filePath
perm := CheckPermission(src)
if perm == true {
return nil, fmt.Errorf("file.CheckPermission Permission denied src: %s", src)
}
err = IsNotExistMkDir(src)
if err != nil {
return nil, fmt.Errorf("file.IsNotExistMkDir src: %s, err: %v", src, err)
}
f, err := Open(src+fileName, os.O_APPEND|os.O_CREATE|os.O_RDWR, 0644)
if err != nil {
return nil, fmt.Errorf("Fail to OpenFile :%v", err)
}
return f, nil
}

54
pkg/logging/file.go
View File

@ -2,43 +2,41 @@ package logging
import (
"fmt"
"log"
"github.com/go-pripro/shop/pkg/file"
"github.com/go-pripro/shop/pkg/setting"
"os"
"time"
)
var (
LogSavePath = "runtime/logs/"
LogSaveName = "log"
LogFileExt = "log"
TimeFormat = "20060102"
)
func getLogFilePath() string {
return fmt.Sprintf("%s", LogSavePath)
return fmt.Sprintf("%s%s", setting.AppSetting.RuntimeRootPath, setting.AppSetting.LogSavePath)
}
func getLogFileFullPath() string {
prefixPath := getLogFilePath()
suffixPath := fmt.Sprintf("%s%s.%s", LogSaveName, time.Now().Format(TimeFormat), LogFileExt)
return fmt.Sprintf("%s%s", prefixPath, suffixPath)
func getLogFileName() string {
return fmt.Sprintf("%s%s.%s",
setting.AppSetting.LogSavename,
time.Now().Format(setting.AppSetting.TimeFormat),
setting.AppSetting.LogFileExt,
)
}
func openLogFile(filePath string) *os.File {
_, err := os.Stat(filePath)
switch {
case os.IsNotExist(err):
mkDir()
case os.IsPermission(err):
log.Fatalf("Permission :%v", err)
}
handle, err := os.OpenFile(filePath, os.O_APPEND | os.O_CREATE | os.O_WRONLY, 0644)
func openLogFile(fileName, filePath string) (*os.File, error) {
dir, err := os.Getwd()
if err != nil {
log.Fatalf("Fail to OpenFile :%v", err)
return nil, fmt.Errorf("os.Getwd err: %v", err)
}
return handle
}
func mkDir() {
dir, _ := os.Getwd()
err := os.MkdirAll(dir + "/" + getLogFilePath(), os.ModePerm)
src := dir + "/" + filePath
perm := file.CheckPermission(src)
if perm == true {
return nil, fmt.Errorf("file.CheckPermission Permission denied src: %s", src)
}
err = file.IsNotExistMkDir(src)
if err != nil {
panic(err)
return nil, fmt.Errorf("file.IsNotExistMkDir src: %s, err: %v", src, err)
}
f, err := file.Open(src + fileName, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
return nil, fmt.Errorf("Fail to OpenFile :%v", err)
}
return f, nil
}

13
pkg/logging/log.go
View File

@ -27,9 +27,16 @@ const (
FATAL
)
func init() {
filePath := getLogFileFullPath()
F = openLogFile(filePath)
func Setup() {
var err error
filePath := getLogFilePath()
fileName := getLogFileName()
F, err = openLogFile(fileName, filePath)
if err != nil {
log.Fatalf("logging.Setup err: %v", err)
}
logger = log.New(F, DefaultPrefix, log.LstdFlags)
}
func Debug(v ...interface{}) {

80
pkg/setting/setting.go
View File

@ -6,50 +6,66 @@ import (
"time"
)
var Cfg *ini.File
var (
type App struct {
JwtSecret string
PageSize int
RuntimeRootPath string
ImagePrefixUrl string
ImageSavePath string
ImageMaxSize int
ImageAllowExts []string
LogSavePath string
LogSavename string
LogFileExt string
TimeFormat string
}
var AppSetting = &App{}
type Server struct {
RunMode string
HTTPPort int
HttpPort int
ReadTimeout time.Duration
WriteTimeout time.Duration
PageSize int
JwtSecret string
)
}
func init() {
var err error
Cfg, err = ini.Load("conf/app.ini")
var ServerSetting = &Server{}
type Database struct {
Type string
User string
Password string
Host string
Port string
Name string
TablePrefix string
}
var DatabaseSetting = &Database{}
func Setup() {
Cfg, err := ini.Load("conf/app.ini")
if err != nil {
log.Fatalf("Fail to parse 'conf/app.ini': %v", err)
}
LoadBase()
LoadServer()
LoadApp()
}
func LoadBase() {
//RunMode = Cfg.Section("server").Key("RUN_MODE").MustString("debug")
}
func LoadServer() {
sec, err := Cfg.GetSection("server")
err = Cfg.Section("app").MapTo(AppSetting)
if err != nil {
log.Fatalf("Fail to get section 'sever' : %v", err)
log.Fatalf("Cfg.MapTo AppSetting err: %v", err)
}
RunMode = sec.Key("RunMode").MustString("debug")
HTTPPort = sec.Key("HttpPort").MustInt(8000)
ReadTimeout = time.Duration(sec.Key("ReadTimeout").MustUint(60)) * time.Second
WriteTimeout = time.Duration(sec.Key("WriteTimeout").MustInt(60)) * time.Second
}
func LoadApp() {
sec, err := Cfg.GetSection("app")
err = Cfg.Section("server").MapTo(ServerSetting)
if err != nil {
log.Fatalf("Fail to get section 'app':%v", err)
log.Fatalf("Cfg.MapTo ServerSetting err: %v", err)
}
JwtSecret = sec.Key("JwtSecret").MustString("!@#!@#!@#!@@#!@#")
PageSize = sec.Key("WriteTimeout").MustInt(10)
ServerSetting.ReadTimeout *= time.Second
ServerSetting.WriteTimeout *= time.Second
err = Cfg.Section("database").MapTo(DatabaseSetting)
if err != nil {
log.Fatalf("Cfg.MapTo DatabaseSetting err: %v", err)
}
}

2
pkg/util/jwt.go
View File

@ -6,7 +6,7 @@ import (
"time"
)
var jwtSecret = []byte(setting.JwtSecret)
var jwtSecret = []byte(setting.AppSetting.JwtSecret)
type Claims struct {
Username string `json:"username"`

2
pkg/util/pagenation.go
View File

@ -10,7 +10,7 @@ func GetPage(c *gin.Context) int {
result := 0
page, _ := com.StrTo(c.Query("page")).Int()
if page > 0 {
result = (page - 1) * setting.PageSize
result = (page - 1) * setting.AppSetting.PageSize
}
return result

2
routers/admin/v1/employee.go
View File

@ -75,7 +75,7 @@ func GetEmployees(c *gin.Context) {
if ! valid.HasErrors() {
code = e.SUCCESS
data["lists"] = models.GetEmployees(util.GetPage(c), setting.PageSize, maps)
data["lists"] = models.GetEmployees(util.GetPage(c), setting.AppSetting.PageSize, maps)
data["total"] = models.GetEmployeeTotal(maps)
} else {
for _, err := range valid.Errors {

2
routers/router.go
View File

@ -15,7 +15,7 @@ func InitRouter() *gin.Engine {
r.Use(gin.Recovery())
gin.SetMode(setting.RunMode)
gin.SetMode(setting.ServerSetting.RunMode)
r.GET("/ping", func(c *gin.Context) {
c.JSON(200, gin.H{