mirror of
https://github.com/kevin-DL/revel-cmd.git
synced 2026-01-11 18:54:31 +00:00
511 lines
16 KiB
Go
511 lines
16 KiB
Go
// This package will be shared between Revel and Revel CLI eventually
|
|
package model
|
|
|
|
import (
|
|
"bufio"
|
|
"fmt"
|
|
"go/build"
|
|
"io"
|
|
"io/fs"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
"unicode"
|
|
|
|
"github.com/revel/cmd/utils"
|
|
"github.com/revel/config"
|
|
"golang.org/x/tools/go/packages"
|
|
)
|
|
|
|
// Error is used for constant errors.
|
|
type Error string
|
|
|
|
// Error implements the error interface.
|
|
func (e Error) Error() string {
|
|
return string(e)
|
|
}
|
|
|
|
const (
|
|
ErrNoApp Error = "no app found at path"
|
|
ErrNoConfig Error = "no config found at path"
|
|
ErrNotFound Error = "not found"
|
|
ErrMissingCert Error = "no http.sslcert provided"
|
|
ErrMissingKey Error = "no http.sslkey provided"
|
|
ErrNoFiles Error = "no files found in import path"
|
|
ErrNoPackages Error = "no packages found for import"
|
|
)
|
|
|
|
type (
|
|
// The container object for describing all Revels variables.
|
|
RevelContainer struct {
|
|
BuildPaths struct {
|
|
Revel string
|
|
}
|
|
Paths struct {
|
|
Import string
|
|
Source string
|
|
Base string
|
|
App string
|
|
Views string
|
|
Code []string
|
|
Template []string
|
|
Config []string
|
|
}
|
|
PackageInfo struct {
|
|
Config config.Context
|
|
Packaged bool
|
|
DevMode bool
|
|
Vendor bool
|
|
}
|
|
Application struct {
|
|
Name string
|
|
Root string
|
|
}
|
|
|
|
ImportPath string // The import path
|
|
SourcePath string // The full source path
|
|
RunMode string // The current run mode
|
|
RevelPath string // The path to the Revel source code
|
|
BasePath string // The base path to the application
|
|
AppPath string // The application path (BasePath + "/app")
|
|
ViewsPath string // The application views path
|
|
CodePaths []string // All the code paths
|
|
TemplatePaths []string // All the template paths
|
|
ConfPaths []string // All the configuration paths
|
|
Config *config.Context // The global config object
|
|
Packaged bool // True if packaged
|
|
DevMode bool // True if running in dev mode
|
|
HTTPPort int // The http port
|
|
HTTPAddr string // The http address
|
|
HTTPSsl bool // True if running https
|
|
HTTPSslCert string // The SSL certificate
|
|
HTTPSslKey string // The SSL key
|
|
AppName string // The application name
|
|
AppRoot string // The application root from the config `app.root`
|
|
CookiePrefix string // The cookie prefix
|
|
CookieDomain string // The cookie domain
|
|
CookieSecure bool // True if cookie is secure
|
|
SecretStr string // The secret string
|
|
MimeConfig *config.Context // The mime configuration
|
|
ModulePathMap map[string]*ModuleInfo // The module path map
|
|
}
|
|
ModuleInfo struct {
|
|
ImportPath string
|
|
Path string
|
|
}
|
|
|
|
WrappedRevelCallback struct {
|
|
FireEventFunction func(key Event, value interface{}) (response EventResponse)
|
|
ImportFunction func(pkgName string) error
|
|
}
|
|
Mod struct {
|
|
ImportPath string
|
|
SourcePath string
|
|
Version string
|
|
SourceVersion string
|
|
Dir string // full path, $GOPATH/pkg/mod/
|
|
Pkgs []string // sub-pkg import paths
|
|
VendorList []string // files to vendor
|
|
}
|
|
)
|
|
|
|
// Simple Wrapped RevelCallback.
|
|
func NewWrappedRevelCallback(fe func(key Event, value interface{}) (response EventResponse), ie func(pkgName string) error) RevelCallback {
|
|
return &WrappedRevelCallback{fe, ie}
|
|
}
|
|
|
|
// Function to implement the FireEvent.
|
|
func (w *WrappedRevelCallback) FireEvent(key Event, value interface{}) (response EventResponse) {
|
|
if w.FireEventFunction != nil {
|
|
response = w.FireEventFunction(key, value)
|
|
}
|
|
return
|
|
}
|
|
|
|
func (w *WrappedRevelCallback) PackageResolver(pkgName string) error {
|
|
return w.ImportFunction(pkgName)
|
|
}
|
|
|
|
// RevelImportPath Revel framework import path.
|
|
var (
|
|
RevelImportPath = "github.com/revel/revel"
|
|
RevelModulesImportPath = "github.com/revel/modules"
|
|
)
|
|
|
|
// This function returns a container object describing the revel application
|
|
// eventually this type of function will replace the global variables.
|
|
func NewRevelPaths(mode, importPath, appSrcPath string, callback RevelCallback) (rp *RevelContainer, err error) {
|
|
rp = &RevelContainer{ModulePathMap: map[string]*ModuleInfo{}}
|
|
// Ignore trailing slashes.
|
|
rp.ImportPath = strings.TrimRight(importPath, "/")
|
|
rp.SourcePath = appSrcPath
|
|
rp.RunMode = mode
|
|
|
|
// We always need to determine the paths for files
|
|
pathMap, err := utils.FindSrcPaths(appSrcPath, []string{importPath + "/app", RevelImportPath}, callback.PackageResolver)
|
|
if err != nil {
|
|
return
|
|
}
|
|
rp.AppPath, rp.RevelPath = pathMap[importPath], pathMap[RevelImportPath]
|
|
// Setup paths for application
|
|
rp.BasePath = rp.SourcePath
|
|
rp.PackageInfo.Vendor = utils.Exists(filepath.Join(rp.BasePath, "go.mod"))
|
|
rp.AppPath = filepath.Join(rp.BasePath, "app")
|
|
|
|
// Sanity check , ensure app and conf paths exist
|
|
if !utils.DirExists(rp.AppPath) {
|
|
return rp, fmt.Errorf("%w: %s", ErrNoApp, rp.AppPath)
|
|
}
|
|
if !utils.DirExists(filepath.Join(rp.BasePath, "conf")) {
|
|
return rp, fmt.Errorf("%w: %s", ErrNoConfig, filepath.Join(rp.BasePath, "conf"))
|
|
}
|
|
|
|
rp.ViewsPath = filepath.Join(rp.AppPath, "views")
|
|
rp.CodePaths = []string{rp.AppPath}
|
|
rp.TemplatePaths = []string{}
|
|
|
|
if rp.ConfPaths == nil {
|
|
rp.ConfPaths = []string{}
|
|
}
|
|
|
|
// Config load order
|
|
// 1. framework (revel/conf/*)
|
|
// 2. application (conf/*)
|
|
// 3. user supplied configs (...) - User configs can override/add any from above
|
|
rp.ConfPaths = append(
|
|
[]string{
|
|
filepath.Join(rp.RevelPath, "conf"),
|
|
filepath.Join(rp.BasePath, "conf"),
|
|
},
|
|
rp.ConfPaths...)
|
|
|
|
rp.Config, err = config.LoadContext("app.conf", rp.ConfPaths)
|
|
if err != nil {
|
|
return rp, fmt.Errorf("unable to load configuration file %w", err)
|
|
}
|
|
|
|
// Ensure that the selected runmode appears in app.conf.
|
|
// If empty string is passed as the mode, treat it as "DEFAULT"
|
|
if mode == "" {
|
|
mode = config.DefaultSection
|
|
}
|
|
if !rp.Config.HasSection(mode) {
|
|
return rp, fmt.Errorf("app.conf: %w %s %s", ErrNotFound, "run-mode", mode)
|
|
}
|
|
rp.Config.SetSection(mode)
|
|
|
|
// Configure properties from app.conf
|
|
rp.DevMode = rp.Config.BoolDefault("mode.dev", false)
|
|
rp.HTTPPort = rp.Config.IntDefault("http.port", 9000)
|
|
rp.HTTPAddr = rp.Config.StringDefault("http.addr", "")
|
|
rp.HTTPSsl = rp.Config.BoolDefault("http.ssl", false)
|
|
rp.HTTPSslCert = rp.Config.StringDefault("http.sslcert", "")
|
|
rp.HTTPSslKey = rp.Config.StringDefault("http.sslkey", "")
|
|
if rp.HTTPSsl {
|
|
if rp.HTTPSslCert == "" {
|
|
return rp, ErrMissingCert
|
|
}
|
|
|
|
if rp.HTTPSslKey == "" {
|
|
return rp, ErrMissingKey
|
|
}
|
|
}
|
|
|
|
rp.AppName = rp.Config.StringDefault("app.name", "(not set)")
|
|
rp.AppRoot = rp.Config.StringDefault("app.root", "")
|
|
rp.CookiePrefix = rp.Config.StringDefault("cookie.prefix", "REVEL")
|
|
rp.CookieDomain = rp.Config.StringDefault("cookie.domain", "")
|
|
rp.CookieSecure = rp.Config.BoolDefault("cookie.secure", rp.HTTPSsl)
|
|
rp.SecretStr = rp.Config.StringDefault("app.secret", "")
|
|
|
|
callback.FireEvent(REVEL_BEFORE_MODULES_LOADED, nil)
|
|
utils.Logger.Info("Loading modules")
|
|
if err := rp.loadModules(callback); err != nil {
|
|
return rp, err
|
|
}
|
|
|
|
callback.FireEvent(REVEL_AFTER_MODULES_LOADED, nil)
|
|
|
|
return
|
|
}
|
|
|
|
// LoadMimeConfig load mime-types.conf on init.
|
|
func (rp *RevelContainer) LoadMimeConfig() (err error) {
|
|
rp.MimeConfig, err = config.LoadContext("mime-types.conf", rp.ConfPaths)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to load mime type config: %s %w", "error", err)
|
|
}
|
|
return
|
|
}
|
|
|
|
// Loads modules based on the configuration setup.
|
|
// This will fire the REVEL_BEFORE_MODULE_LOADED, REVEL_AFTER_MODULE_LOADED
|
|
// for each module loaded. The callback will receive the RevelContainer, name, moduleImportPath and modulePath
|
|
// It will automatically add in the code paths for the module to the
|
|
// container object.
|
|
func (rp *RevelContainer) loadModules(callback RevelCallback) (err error) {
|
|
keys := []string{}
|
|
keys = append(keys, rp.Config.Options("module.")...)
|
|
|
|
// Reorder module order by key name, a poor mans sort but at least it is consistent
|
|
sort.Strings(keys)
|
|
modtxtPath := filepath.Join(rp.SourcePath, "vendor", "modules.txt")
|
|
if utils.Exists(modtxtPath) {
|
|
// Parse out require sections of module.txt
|
|
modules := rp.vendorInitilizeLocal(modtxtPath, keys)
|
|
for _, mod := range modules {
|
|
for _, vendorFile := range mod.VendorList {
|
|
x := strings.Index(vendorFile, mod.Dir)
|
|
if x < 0 {
|
|
utils.Logger.Crit("Error! vendor file doesn't belong to mod, strange.", "vendorFile", "mod.Dir", mod.Dir)
|
|
}
|
|
|
|
localPath := fmt.Sprintf("%s%s", mod.ImportPath, vendorFile[len(mod.Dir):])
|
|
localFile := filepath.Join(rp.SourcePath, "vendor", localPath)
|
|
|
|
utils.Logger.Infof("vendoring %s\n", localPath)
|
|
|
|
os.MkdirAll(filepath.Dir(localFile), os.ModePerm)
|
|
if _, err := copyFile(vendorFile, localFile); err != nil {
|
|
fmt.Printf("Error! %s - unable to copy file %s\n", err.Error(), vendorFile)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for _, key := range keys {
|
|
moduleImportPath := rp.Config.StringDefault(key, "")
|
|
if moduleImportPath == "" {
|
|
continue
|
|
}
|
|
|
|
modulePath, err := rp.ResolveImportPath(moduleImportPath)
|
|
utils.Logger.Info("Resolving import path ", "modulePath", modulePath, "module_import_path", moduleImportPath, "error", err)
|
|
if err != nil {
|
|
|
|
if err := callback.PackageResolver(moduleImportPath); err != nil {
|
|
return fmt.Errorf("failed to resolve package %w", err)
|
|
}
|
|
|
|
modulePath, err = rp.ResolveImportPath(moduleImportPath)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to load module. Import of path failed %s:%s %s:%w ", "modulePath", moduleImportPath, "error", err)
|
|
}
|
|
}
|
|
// Drop anything between module.???.<name of module>
|
|
name := key[len("module."):]
|
|
if index := strings.Index(name, "."); index > -1 {
|
|
name = name[index+1:]
|
|
}
|
|
callback.FireEvent(REVEL_BEFORE_MODULE_LOADED, []interface{}{rp, name, moduleImportPath, modulePath})
|
|
rp.addModulePaths(name, moduleImportPath, modulePath)
|
|
callback.FireEvent(REVEL_AFTER_MODULE_LOADED, []interface{}{rp, name, moduleImportPath, modulePath})
|
|
}
|
|
return
|
|
}
|
|
|
|
// Adds a module paths to the container object.
|
|
func (rp *RevelContainer) vendorInitilizeLocal(modtxtPath string, revel_modules_keys []string) []*Mod {
|
|
revel_modules := []string{"github.com/revel/revel"}
|
|
for _, key := range revel_modules_keys {
|
|
moduleImportPath := rp.Config.StringDefault(key, "")
|
|
if moduleImportPath == "" {
|
|
continue
|
|
}
|
|
revel_modules = append(revel_modules, moduleImportPath)
|
|
}
|
|
f, _ := os.Open(modtxtPath)
|
|
defer f.Close()
|
|
scanner := bufio.NewScanner(f)
|
|
scanner.Split(bufio.ScanLines)
|
|
|
|
var (
|
|
mod *Mod
|
|
err error
|
|
)
|
|
modules := []*Mod{}
|
|
|
|
for scanner.Scan() {
|
|
line := scanner.Text()
|
|
|
|
// Look for # character
|
|
if line[0] == 35 {
|
|
s := strings.Split(line, " ")
|
|
if (len(s) != 6 && len(s) != 3) || s[1] == "explicit" {
|
|
continue
|
|
}
|
|
|
|
mod = &Mod{
|
|
ImportPath: s[1],
|
|
Version: s[2],
|
|
}
|
|
if s[2] == "=>" {
|
|
// issue https://github.com/golang/go/issues/33848 added these,
|
|
// see comments. I think we can get away with ignoring them.
|
|
continue
|
|
}
|
|
// Handle "replace" in module file if any
|
|
if len(s) > 3 && s[3] == "=>" {
|
|
mod.SourcePath = s[4]
|
|
|
|
// Handle replaces with a relative target. For example:
|
|
// "replace github.com/status-im/status-go/protocol => ./protocol"
|
|
if strings.HasPrefix(s[4], ".") || strings.HasPrefix(s[4], "/") {
|
|
mod.Dir, err = filepath.Abs(s[4])
|
|
if err != nil {
|
|
fmt.Printf("invalid relative path: %v", err)
|
|
os.Exit(1)
|
|
}
|
|
} else {
|
|
mod.SourceVersion = s[5]
|
|
mod.Dir = pkgModPath(mod.SourcePath, mod.SourceVersion)
|
|
}
|
|
} else {
|
|
mod.Dir = pkgModPath(mod.ImportPath, mod.Version)
|
|
}
|
|
|
|
if _, err := os.Stat(mod.Dir); os.IsNotExist(err) {
|
|
utils.Logger.Critf("Error! %q module path does not exist, check $GOPATH/pkg/mod\n", mod.Dir)
|
|
}
|
|
|
|
// Determine if we need to examine this mod, based on the list of modules being imported
|
|
for _, importPath := range revel_modules {
|
|
if strings.HasPrefix(importPath, mod.ImportPath) {
|
|
updateModVendorList(mod, importPath)
|
|
}
|
|
}
|
|
|
|
// Build list of files to module path source to project vendor folder
|
|
modules = append(modules, mod)
|
|
|
|
continue
|
|
}
|
|
|
|
mod.Pkgs = append(mod.Pkgs, line)
|
|
}
|
|
return modules
|
|
}
|
|
|
|
// Adds a module paths to the container object.
|
|
func (rp *RevelContainer) addModulePaths(name, importPath, modulePath string) {
|
|
utils.Logger.Info("Adding module path", "name", name, "import path", importPath, "system path", modulePath)
|
|
if codePath := filepath.Join(modulePath, "app"); utils.DirExists(codePath) {
|
|
rp.CodePaths = append(rp.CodePaths, codePath)
|
|
rp.ModulePathMap[name] = &ModuleInfo{importPath, modulePath}
|
|
if viewsPath := filepath.Join(modulePath, "app", "views"); utils.DirExists(viewsPath) {
|
|
rp.TemplatePaths = append(rp.TemplatePaths, viewsPath)
|
|
}
|
|
}
|
|
|
|
// Hack: There is presently no way for the testrunner module to add the
|
|
// "test" subdirectory to the CodePaths. So this does it instead.
|
|
if importPath == rp.Config.StringDefault("module.testrunner", "github.com/revel/modules/testrunner") {
|
|
joinedPath := filepath.Join(rp.BasePath, "tests")
|
|
rp.CodePaths = append(rp.CodePaths, joinedPath)
|
|
}
|
|
if testsPath := filepath.Join(modulePath, "tests"); utils.DirExists(testsPath) {
|
|
rp.CodePaths = append(rp.CodePaths, testsPath)
|
|
}
|
|
}
|
|
|
|
// ResolveImportPath returns the filesystem path for the given import path.
|
|
// Returns an error if the import path could not be found.
|
|
func (rp *RevelContainer) ResolveImportPath(importPath string) (string, error) {
|
|
if rp.Packaged {
|
|
return filepath.Join(rp.SourcePath, importPath), nil
|
|
}
|
|
config := &packages.Config{
|
|
Mode: packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles | packages.NeedImports |
|
|
packages.NeedTypes | packages.NeedTypesSizes | packages.NeedSyntax | packages.NeedTypesInfo,
|
|
Dir: rp.AppPath,
|
|
}
|
|
config.Env = utils.ReducedEnv(false)
|
|
pkgs, err := packages.Load(config, importPath)
|
|
if len(pkgs) == 0 {
|
|
return "", fmt.Errorf("%w %s using app path %s", ErrNoPackages, importPath, rp.AppPath)
|
|
}
|
|
// modPkg, err := build.Import(importPath, rp.AppPath, build.FindOnly)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if len(pkgs[0].GoFiles) > 0 {
|
|
return filepath.Dir(pkgs[0].GoFiles[0]), nil
|
|
}
|
|
return pkgs[0].PkgPath, fmt.Errorf("%w: %s", ErrNoFiles, importPath)
|
|
}
|
|
|
|
func normString(str string) (normStr string) {
|
|
for _, char := range str {
|
|
if unicode.IsUpper(char) {
|
|
normStr += "!" + string(unicode.ToLower(char))
|
|
} else {
|
|
normStr += string(char)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func pkgModPath(importPath, version string) string {
|
|
goPath := build.Default.GOPATH
|
|
if goPath == "" {
|
|
if goPath = os.Getenv("GOPATH"); goPath == "" {
|
|
// the default GOPATH for go v1.11
|
|
goPath = filepath.Join(os.Getenv("HOME"), "go")
|
|
}
|
|
}
|
|
|
|
normPath := normString(importPath)
|
|
normVersion := normString(version)
|
|
|
|
return filepath.Join(goPath, "pkg", "mod", fmt.Sprintf("%s@%s", normPath, normVersion))
|
|
}
|
|
|
|
func copyFile(src, dst string) (int64, error) {
|
|
srcStat, err := os.Stat(src)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if !srcStat.Mode().IsRegular() {
|
|
return 0, fmt.Errorf("%s is not a regular file", src)
|
|
}
|
|
|
|
srcFile, err := os.Open(src)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
defer srcFile.Close()
|
|
|
|
dstFile, err := os.Create(dst)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
defer dstFile.Close()
|
|
|
|
return io.Copy(dstFile, srcFile)
|
|
}
|
|
|
|
func updateModVendorList(mod *Mod, importPath string) {
|
|
vendorList := []string{}
|
|
pathPrefix := filepath.Join(mod.Dir, importPath[len(mod.ImportPath):])
|
|
|
|
filepath.WalkDir(pathPrefix, func(path string, d fs.DirEntry, err error) (e error) {
|
|
if d.IsDir() {
|
|
return
|
|
}
|
|
|
|
if err != nil {
|
|
utils.Logger.Crit("Failed to walk vendor dir")
|
|
}
|
|
utils.Logger.Info("Adding to file in vendor list", "path", path)
|
|
vendorList = append(vendorList, path)
|
|
return
|
|
})
|
|
|
|
utils.Logger.Info("For module", "module", mod.ImportPath, "files", len(vendorList))
|
|
|
|
mod.VendorList = append(mod.VendorList, vendorList...)
|
|
}
|