func Message(hl, msg string) {
if PureMode {
message(hl, msg)
return
}
if !Verbose {
return
}
if len(hl) > 0 {
hl = " " + brush.Yellow(hl).String()
}
fmt.Printf("gopm %s%s %s\n", brush.Yellow("MSG!"), hl, msg)
}
func installToolchains(langs []toolchainInstaller) error {
var notInstalled []string
for _, l := range langs {
fmt.Println(brush.Cyan(l.name + " " + strings.Repeat("=", 78-len(l.name))).String())
if err := l.fn(); err != nil {
if err2, ok := err.(skippedToolchain); ok {
fmt.Printf("%s\n", brush.Yellow(err2.Error()))
} else {
fmt.Printf("%s\n", brush.Red(fmt.Sprintf("failed to install/upgrade %s toolchain: %s", l.name, err)))
}
notInstalled = append(notInstalled, l.name)
// Continue here because we attempt to install
// all the toolchains.
continue
}
fmt.Println(brush.Green("OK! Installed/upgraded " + l.name + " toolchain").String())
fmt.Println(brush.Cyan(strings.Repeat("=", 80)).String())
fmt.Println()
}
if len(notInstalled) != 0 {
return errors.New(brush.Red(fmt.Sprintf("The following toolchains were not installed:\n%s", strings.Join(notInstalled, "\n"))).String())
}
return nil
}
func (c *ToolchainInstallStdCmd) Execute(args []string) error {
fmt.Println(brush.Cyan("Installing/upgrading standard toolchains..."))
fmt.Println()
var is []toolchainInstaller
OuterLoop:
for name, installer := range stdToolchains {
for _, skip := range c.Skip {
if strings.EqualFold(name, skip) {
fmt.Println(brush.Yellow(fmt.Sprintf("Skipping installation of %s", installer.name)))
continue OuterLoop
}
}
is = append(is, installer)
}
return installToolchains(is)
}
func makeLogMux(conf *Config) (*logMux, error) {
fileVerb, err := getVerbosityLevel(conf.LogFileVerbosity)
if err != nil {
return nil, fmt.Errorf("log file verbosity, %v", err)
}
consoleVerb, err := getVerbosityLevel(conf.ConsoleVerbosity)
if err != nil {
return nil, fmt.Errorf("console verbosity, %v", err)
}
filename := conf.LogFilename
file, err := os.OpenFile(filename, os.O_APPEND|os.O_WRONLY, 0640)
if os.IsNotExist(err) {
file, err = os.Create(filename)
}
if err != nil {
return nil, fmt.Errorf("opening log file %s, %v", filename, err)
}
debugPfx := fmt.Sprintf("%s%s%s ",
brush.DarkGray("["),
brush.Blue("DEBUG"),
brush.DarkGray("]"))
watchPfx := fmt.Sprintf("%s%s%s ",
brush.DarkGray("["),
brush.DarkCyan("WATCH"),
brush.DarkGray("]"))
infoPfx := fmt.Sprintf(" %s%s%s ",
brush.DarkGray("["),
brush.Green("INFO"),
brush.DarkGray("]"))
warnPfx := fmt.Sprintf(" %s%s%s ",
brush.DarkGray("["),
brush.Yellow("WARN"),
brush.DarkGray("]"))
errPfx := fmt.Sprintf("%s%s%s ",
brush.DarkGray("["),
brush.Red("ERROR"),
brush.DarkGray("]"))
return &logMux{
logFile: file,
debugFile: log.New(file, "[DEBUG] ", log.LstdFlags),
watchFile: log.New(file, "[WATCH] ", log.LstdFlags),
infoFile: log.New(file, " [INFO] ", log.LstdFlags),
warnFile: log.New(file, " [WARN] ", log.LstdFlags),
errorFile: log.New(file, "[ERROR] ", log.LstdFlags),
debugConsole: log.New(os.Stdout, debugPfx, log.LstdFlags),
watchConsole: log.New(os.Stdout, watchPfx, log.LstdFlags),
infoConsole: log.New(os.Stdout, infoPfx, log.LstdFlags),
warnConsole: log.New(os.Stdout, warnPfx, log.LstdFlags),
errorConsole: log.New(os.Stderr, errPfx, log.LstdFlags),
fileVerbose: fileVerb,
consoleVerbose: consoleVerb,
}, nil
}
var stdout_std_logger *log.Logger
var stderr_std_logger *log.Logger
var prefixes = map[int]string{
DEBUG: "[debug] ",
INFO: "[info] ",
WARNING: "[warning] ",
ERROR: "[error] ",
FATAL: "[fatal] ",
}
var coloredPrefixes = map[int]string{
DEBUG: brush.Cyan("[debug] ").String(),
INFO: brush.Green("[info] ").String(),
WARNING: brush.Yellow("[warning] ").String(),
ERROR: brush.Red("[error] ").String(),
FATAL: brush.DarkRed("[fatal] ").String(),
}
type Stdout struct {
MinLevel int
Colored bool
}
func init() {
stdout_std_logger = log.New(os.Stdout, "", log.Ldate|log.Ltime|log.Lshortfile)
stderr_std_logger = log.New(os.Stderr, "", log.Ldate|log.Ltime|log.Lshortfile)
}
func (s Stdout) std_format_message(level int, message string) (int, string) {
func Yellow(s string) string {
if Colorize {
return brush.Yellow(s).String()
}
return s
}
