msb-public
/
Open-IM-Server
mirror of https://github.com/OpenIMSDK/Open-IM-Server
2
0
Code Issues Projects Releases Wiki Activity

update license

Browse Source
pull/3293/head
skiffer-git 5 months ago
parent 39fc902304
commit 4a233a26f3
1 changed files with 0 additions and 498 deletions
Show Stats Download Patch File Download Diff File

498
mage_output_file.go
Unescape View File

@ -1,498 +0,0 @@
//go:build ignore
// +build ignore
package main
import (
"context"
_flag "flag"
_fmt "fmt"
_ioutil "io/ioutil"
_log "log"
"os"
"os/signal"
_filepath "path/filepath"
_sort "sort"
"strconv"
_strings "strings"
"syscall"
_tabwriter "text/tabwriter"
"time"
)
func main() {
// Use local types and functions in order to avoid name conflicts with additional magefiles.
type arguments struct {
Verbose bool // print out log statements
List bool // print out a list of targets
Help bool // print out help for a specific target
Timeout time.Duration // set a timeout to running the targets
Args []string // args contain the non-flag command-line arguments
}
parseBool := func(env string) bool {
val := os.Getenv(env)
if val == "" {
return false
}
b, err := strconv.ParseBool(val)
if err != nil {
_log.Printf("warning: environment variable %s is not a valid bool value: %v", env, val)
return false
}
return b
}
parseDuration := func(env string) time.Duration {
val := os.Getenv(env)
if val == "" {
return 0
}
d, err := time.ParseDuration(val)
if err != nil {
_log.Printf("warning: environment variable %s is not a valid duration value: %v", env, val)
return 0
}
return d
}
args := arguments{}
fs := _flag.FlagSet{}
fs.SetOutput(os.Stdout)
// default flag set with ExitOnError and auto generated PrintDefaults should be sufficient
fs.BoolVar(&args.Verbose, "v", parseBool("MAGEFILE_VERBOSE"), "show verbose output when running targets")
fs.BoolVar(&args.List, "l", parseBool("MAGEFILE_LIST"), "list targets for this binary")
fs.BoolVar(&args.Help, "h", parseBool("MAGEFILE_HELP"), "print out help for a specific target")
fs.DurationVar(&args.Timeout, "t", parseDuration("MAGEFILE_TIMEOUT"), "timeout in duration parsable format (e.g. 5m30s)")
fs.Usage = func() {
_fmt.Fprintf(os.Stdout, `
%s [options] [target]
Commands:
-l list targets in this binary
-h show this help
Options:
-h show description of a target
-t <string>
timeout in duration parsable format (e.g. 5m30s)
-v show verbose output when running targets
`[1:], _filepath.Base(os.Args[0]))
}
if err := fs.Parse(os.Args[1:]); err != nil {
// flag will have printed out an error already.
return
}
args.Args = fs.Args()
if args.Help && len(args.Args) == 0 {
fs.Usage()
return
}
// color is ANSI color type
type color int
// If you add/change/remove any items in this constant,
// you will need to run "stringer -type=color" in this directory again.
// NOTE: Please keep the list in an alphabetical order.
const (
black color = iota
red
green
yellow
blue
magenta
cyan
white
brightblack
brightred
brightgreen
brightyellow
brightblue
brightmagenta
brightcyan
brightwhite
)
// AnsiColor are ANSI color codes for supported terminal colors.
var ansiColor = map[color]string{
black: "\u001b[30m",
red: "\u001b[31m",
green: "\u001b[32m",
yellow: "\u001b[33m",
blue: "\u001b[34m",
magenta: "\u001b[35m",
cyan: "\u001b[36m",
white: "\u001b[37m",
brightblack: "\u001b[30;1m",
brightred: "\u001b[31;1m",
brightgreen: "\u001b[32;1m",
brightyellow: "\u001b[33;1m",
brightblue: "\u001b[34;1m",
brightmagenta: "\u001b[35;1m",
brightcyan: "\u001b[36;1m",
brightwhite: "\u001b[37;1m",
}
const _color_name = "blackredgreenyellowbluemagentacyanwhitebrightblackbrightredbrightgreenbrightyellowbrightbluebrightmagentabrightcyanbrightwhite"
var _color_index = [...]uint8{0, 5, 8, 13, 19, 23, 30, 34, 39, 50, 59, 70, 82, 92, 105, 115, 126}
colorToLowerString := func(i color) string {
if i < 0 || i >= color(len(_color_index)-1) {
return "color(" + strconv.FormatInt(int64(i), 10) + ")"
}
return _color_name[_color_index[i]:_color_index[i+1]]
}
// ansiColorReset is an ANSI color code to reset the terminal color.
const ansiColorReset = "\033[0m"
// defaultTargetAnsiColor is a default ANSI color for colorizing targets.
// It is set to Cyan as an arbitrary color, because it has a neutral meaning
var defaultTargetAnsiColor = ansiColor[cyan]
getAnsiColor := func(color string) (string, bool) {
colorLower := _strings.ToLower(color)
for k, v := range ansiColor {
colorConstLower := colorToLowerString(k)
if colorConstLower == colorLower {
return v, true
}
}
return "", false
}
// Terminals which don't support color:
// TERM=vt100
// TERM=cygwin
// TERM=xterm-mono
var noColorTerms = map[string]bool{
"vt100": false,
"cygwin": false,
"xterm-mono": false,
}
// terminalSupportsColor checks if the current console supports color output
//
// Supported:
// linux, mac, or windows's ConEmu, Cmder, putty, git-bash.exe, pwsh.exe
// Not supported:
// windows cmd.exe, powerShell.exe
terminalSupportsColor := func() bool {
envTerm := os.Getenv("TERM")
if _, ok := noColorTerms[envTerm]; ok {
return false
}
return true
}
// enableColor reports whether the user has requested to enable a color output.
enableColor := func() bool {
b, _ := strconv.ParseBool(os.Getenv("MAGEFILE_ENABLE_COLOR"))
return b
}
// targetColor returns the ANSI color which should be used to colorize targets.
targetColor := func() string {
s, exists := os.LookupEnv("MAGEFILE_TARGET_COLOR")
if exists == true {
if c, ok := getAnsiColor(s); ok == true {
return c
}
}
return defaultTargetAnsiColor
}
// store the color terminal variables, so that the detection isn't repeated for each target
var enableColorValue = enableColor() && terminalSupportsColor()
var targetColorValue = targetColor()
printName := func(str string) string {
if enableColorValue {
return _fmt.Sprintf("%s%s%s", targetColorValue, str, ansiColorReset)
} else {
return str
}
}
list := func() error {
targets := map[string]string{
"build*": "",
"check": "",
"start": "",
"stop": "",
}
keys := make([]string, 0, len(targets))
for name := range targets {
keys = append(keys, name)
}
_sort.Strings(keys)
_fmt.Println("Targets:")
w := _tabwriter.NewWriter(os.Stdout, 0, 4, 4, ' ', 0)
for _, name := range keys {
_fmt.Fprintf(w, " %v\t%v\n", printName(name), targets[name])
}
err := w.Flush()
if err == nil {
_fmt.Println("\n* default target")
}
return err
}
var ctx context.Context
ctxCancel := func() {}
// by deferring in a closure, we let the cancel function get replaced
// by the getContext function.
defer func() {
ctxCancel()
}()
getContext := func() (context.Context, func()) {
if ctx == nil {
if args.Timeout != 0 {
ctx, ctxCancel = context.WithTimeout(context.Background(), args.Timeout)
} else {
ctx, ctxCancel = context.WithCancel(context.Background())
}
}
return ctx, ctxCancel
}
runTarget := func(logger *_log.Logger, fn func(context.Context) error) interface{} {
var err interface{}
ctx, cancel := getContext()
d := make(chan interface{})
go func() {
defer func() {
err := recover()
d <- err
}()
err := fn(ctx)
d <- err
}()
sigCh := make(chan os.Signal, 1)
signal.Notify(sigCh, syscall.SIGINT)
select {
case <-sigCh:
logger.Println("cancelling mage targets, waiting up to 5 seconds for cleanup...")
cancel()
cleanupCh := time.After(5 * time.Second)
select {
// target exited by itself
case err = <-d:
return err
// cleanup timeout exceeded
case <-cleanupCh:
return _fmt.Errorf("cleanup timeout exceeded")
// second SIGINT received
case <-sigCh:
logger.Println("exiting mage")
return _fmt.Errorf("exit forced")
}
case <-ctx.Done():
cancel()
e := ctx.Err()
_fmt.Printf("ctx err: %v\n", e)
return e
case err = <-d:
// we intentionally don't cancel the context here, because
// the next target will need to run with the same context.
return err
}
}
// This is necessary in case there aren't any targets, to avoid an unused
// variable error.
_ = runTarget
handleError := func(logger *_log.Logger, err interface{}) {
if err != nil {
logger.Printf("Error: %+v\n", err)
type code interface {
ExitStatus() int
}
if c, ok := err.(code); ok {
os.Exit(c.ExitStatus())
}
os.Exit(1)
}
}
_ = handleError
// Set MAGEFILE_VERBOSE so mg.Verbose() reflects the flag value.
if args.Verbose {
os.Setenv("MAGEFILE_VERBOSE", "1")
} else {
os.Setenv("MAGEFILE_VERBOSE", "0")
}
_log.SetFlags(0)
if !args.Verbose {
_log.SetOutput(_ioutil.Discard)
}
logger := _log.New(os.Stderr, "", 0)
if args.List {
if err := list(); err != nil {
_log.Println(err)
os.Exit(1)
}
return
}
if args.Help {
if len(args.Args) < 1 {
logger.Println("no target specified")
os.Exit(2)
}
switch _strings.ToLower(args.Args[0]) {
case "build":
_fmt.Print("Usage:\n\n\tmage build\n\n")
var aliases []string
if len(aliases) > 0 {
_fmt.Printf("Aliases: %s\n\n", _strings.Join(aliases, ", "))
}
return
case "check":
_fmt.Print("Usage:\n\n\tmage check\n\n")
var aliases []string
if len(aliases) > 0 {
_fmt.Printf("Aliases: %s\n\n", _strings.Join(aliases, ", "))
}
return
case "start":
_fmt.Print("Usage:\n\n\tmage start\n\n")
var aliases []string
if len(aliases) > 0 {
_fmt.Printf("Aliases: %s\n\n", _strings.Join(aliases, ", "))
}
return
case "stop":
_fmt.Print("Usage:\n\n\tmage stop\n\n")
var aliases []string
if len(aliases) > 0 {
_fmt.Printf("Aliases: %s\n\n", _strings.Join(aliases, ", "))
}
return
default:
logger.Printf("Unknown target: %q\n", args.Args[0])
os.Exit(2)
}
}
if len(args.Args) < 1 {
ignoreDefault, _ := strconv.ParseBool(os.Getenv("MAGEFILE_IGNOREDEFAULT"))
if ignoreDefault {
if err := list(); err != nil {
logger.Println("Error:", err)
os.Exit(1)
}
return
}
wrapFn := func(ctx context.Context) error {
Build()
return nil
}
ret := runTarget(logger, wrapFn)
handleError(logger, ret)
return
}
for x := 0; x < len(args.Args); {
target := args.Args[x]
x++
// resolve aliases
switch _strings.ToLower(target) {
}
switch _strings.ToLower(target) {
case "build":
expected := x + 0
if expected > len(args.Args) {
// note that expected and args at this point include the arg for the target itself
// so we subtract 1 here to show the number of args without the target.
logger.Printf("not enough arguments for target \"Build\", expected %v, got %v\n", expected-1, len(args.Args)-1)
os.Exit(2)
}
if args.Verbose {
logger.Println("Running target:", "Build")
}
wrapFn := func(ctx context.Context) error {
Build()
return nil
}
ret := runTarget(logger, wrapFn)
handleError(logger, ret)
case "check":
expected := x + 0
if expected > len(args.Args) {
// note that expected and args at this point include the arg for the target itself
// so we subtract 1 here to show the number of args without the target.
logger.Printf("not enough arguments for target \"Check\", expected %v, got %v\n", expected-1, len(args.Args)-1)
os.Exit(2)
}
if args.Verbose {
logger.Println("Running target:", "Check")
}
wrapFn := func(ctx context.Context) error {
Check()
return nil
}
ret := runTarget(logger, wrapFn)
handleError(logger, ret)
case "start":
expected := x + 0
if expected > len(args.Args) {
// note that expected and args at this point include the arg for the target itself
// so we subtract 1 here to show the number of args without the target.
logger.Printf("not enough arguments for target \"Start\", expected %v, got %v\n", expected-1, len(args.Args)-1)
os.Exit(2)
}
if args.Verbose {
logger.Println("Running target:", "Start")
}
wrapFn := func(ctx context.Context) error {
Start()
return nil
}
ret := runTarget(logger, wrapFn)
handleError(logger, ret)
case "stop":
expected := x + 0
if expected > len(args.Args) {
// note that expected and args at this point include the arg for the target itself
// so we subtract 1 here to show the number of args without the target.
logger.Printf("not enough arguments for target \"Stop\", expected %v, got %v\n", expected-1, len(args.Args)-1)
os.Exit(2)
}
if args.Verbose {
logger.Println("Running target:", "Stop")
}
wrapFn := func(ctx context.Context) error {
Stop()
return nil
}
ret := runTarget(logger, wrapFn)
handleError(logger, ret)
default:
logger.Printf("Unknown target specified: %q\n", target)
os.Exit(2)
}
}
}
Write Preview
Loading…
Cancel
Save