Merge pull request #82 from Rbeuque74/master

ochinchina · web-flow · commit 7b21d2c6d360 · 2018-03-20T09:57:08.000+08:00
fixing major reports from gometalinter
diff --git a/.travis.yml b/.travis.yml
@@ -3,5 +3,10 @@ language: go
 go:
 - "1.10.x"
 
+after_script:
+  - go get -v github.com/alecthomas/gometalinter/...
+  - gometalinter --install
+  - gometalinter
+
 after_success:
   - test -n "$TRAVIS_TAG" && curl -sL https://git.io/goreleaser | bash
diff --git a/README.md b/README.md
@@ -1,3 +1,5 @@
+[![Go Report Card](https://goreportcard.com/badge/github.com/ochinchina/supervisord)](https://goreportcard.com/report/github.com/ochinchina/supervisord)
+
 # Why this project?
 
 The python script supervisord is a powerful tool used by a lot of guys to manage the processes. I like the tool supervisord also.
diff --git a/config/config.go b/config/config.go
@@ -10,8 +10,8 @@ import (
 	"strconv"
 	"strings"
 
-	log "github.com/sirupsen/logrus"
 	ini "github.com/ochinchina/go-ini"
+	log "github.com/sirupsen/logrus"
 )
 
 type ConfigEntry struct {
@@ -205,9 +205,9 @@ func (c *Config) GetInetHttpServer() (*ConfigEntry, bool) {
 	return entry, ok
 }
 
-func (c *Config)GetSupervisorctl() (*ConfigEntry, bool ) {
-    entry, ok := c.entries[ "supervisorctl" ]
-    return entry, ok
+func (c *Config) GetSupervisorctl() (*ConfigEntry, bool) {
+	entry, ok := c.entries["supervisorctl"]
+	return entry, ok
 }
 func (c *Config) GetEntries(filterFunc func(entry *ConfigEntry) bool) []*ConfigEntry {
 	result := make([]*ConfigEntry, 0)
@@ -298,7 +298,7 @@ func (c *ConfigEntry) GetInt(key string, defValue int) int {
 	return defValue
 }
 
-// get the value of key as environment setting. An enviroment string example:
+// GetEnv get the value of key as environment setting. An environment string example:
 //  environment = A="env 1",B="this is a test"
 func (c *ConfigEntry) GetEnv(key string) []string {
 	value, ok := c.keyValues[key]
@@ -363,13 +363,12 @@ func (c *ConfigEntry) GetString(key string, defValue string) string {
 		rep_s, err := env.Eval(s)
 		if err == nil {
 			return rep_s
-		} else {
-			log.WithFields(log.Fields{
-				log.ErrorKey: err,
-				"program":    c.GetProgramName(),
-				"key":        key,
-			}).Warn("Unable to parse expression")
 		}
+		log.WithFields(log.Fields{
+			log.ErrorKey: err,
+			"program":    c.GetProgramName(),
+			"key":        key,
+		}).Warn("Unable to parse expression")
 	}
 	return defValue
 }
diff --git a/config/process_group.go b/config/process_group.go
@@ -59,7 +59,7 @@ func (pg *ProcessGroup) GetAllGroup() []string {
 	}
 
 	result := make([]string, 0)
-	for group, _ := range groups {
+	for group := range groups {
 		result = append(result, group)
 	}
 	return result
diff --git a/config/process_sort.go b/config/process_sort.go
@@ -80,15 +80,15 @@ func (p *ProcessSorter) sortDepends() []string {
 	progs_start_order := make([]string, 0)
 
 	//get all process without depends
-	for prog_name, _ := range progs_with_depends_info {
+	for prog_name := range progs_with_depends_info {
 		if _, ok := p.depends_on_gragh[prog_name]; !ok {
 			finished_programs[prog_name] = prog_name
 			progs_start_order = append(progs_start_order, prog_name)
 		}
 	}
 
 	for len(finished_programs) < len(progs_with_depends_info) {
-		for prog_name, _ := range p.depends_on_gragh {
+		for prog_name := range p.depends_on_gragh {
 			if _, ok := finished_programs[prog_name]; !ok && p.inFinishedPrograms(prog_name, finished_programs) {
 				finished_programs[prog_name] = prog_name
 				progs_start_order = append(progs_start_order, prog_name)
diff --git a/content_checker.go b/content_checker.go
@@ -98,7 +98,7 @@ func NewTcpChecker(host string, port int, includes []string, timeout int) *TcpCh
 func (tc *TcpChecker) start() {
 	go func() {
 		b := make([]byte, 1024)
-		var err error = nil
+		var err error
 		for {
 			tc.conn, err = net.Dial("tcp", fmt.Sprintf("%s:%d", tc.host, tc.port))
 			if err == nil || tc.baseChecker.timeoutTime.Before(time.Now()) {
@@ -145,5 +145,4 @@ func (hc *HttpChecker) Check() bool {
 			}
 		}
 	}
-	return false
 }
diff --git a/daemonize.go b/daemonize.go
@@ -3,8 +3,8 @@
 package main
 
 import (
+	daemon "github.com/sevlyar/go-daemon"
 	log "github.com/sirupsen/logrus"
-	"github.com/sevlyar/go-daemon"
 )
 
 func Deamonize(proc func()) {
diff --git a/daemonize_windows.go b/daemonize_windows.go
@@ -1,7 +1,7 @@
-package main
-
 // +build windows
 
+package main
+
 func Deamonize(proc func()) {
 	proc()
 }
diff --git a/events/events.go b/events/events.go
@@ -196,10 +196,8 @@ func (el *EventListener) readResult() (string, error) {
 		}
 		//ok, get the n bytes
 		return string(b), nil
-	} else {
-		return "", fmt.Errorf("Fail to read the result")
 	}
-
+	return "", fmt.Errorf("Fail to read the result")
 }
 
 func (el *EventListener) HandleEvent(event Event) {
@@ -234,27 +232,27 @@ func (el *EventListener) encodeEvent(event Event) []byte {
 }
 
 var eventTypeDerives = map[string][]string{
-	"PROCESS_STATE_STARTING":           []string{"EVENT", "PROCESS_STATE"},
-	"PROCESS_STATE_RUNNING":            []string{"EVENT", "PROCESS_STATE"},
-	"PROCESS_STATE_BACKOFF":            []string{"EVENT", "PROCESS_STATE"},
-	"PROCESS_STATE_STOPPING":           []string{"EVENT", "PROCESS_STATE"},
-	"PROCESS_STATE_EXITED":             []string{"EVENT", "PROCESS_STATE"},
-	"PROCESS_STATE_STOPPED":            []string{"EVENT", "PROCESS_STATE"},
-	"PROCESS_STATE_FATAL":              []string{"EVENT", "PROCESS_STATE"},
-	"PROCESS_STATE_UNKNOWN":            []string{"EVENT", "PROCESS_STATE"},
-	"REMOTE_COMMUNICATION":             []string{"EVENT"},
-	"PROCESS_LOG_STDOUT":               []string{"EVENT", "PROCESS_LOG"},
-	"PROCESS_LOG_STDERR":               []string{"EVENT", "PROCESS_LOG"},
-	"PROCESS_COMMUNICATION_STDOUT":     []string{"EVENT", "PROCESS_COMMUNICATION"},
-	"PROCESS_COMMUNICATION_STDERR":     []string{"EVENT", "PROCESS_COMMUNICATION"},
-	"SUPERVISOR_STATE_CHANGE_RUNNING":  []string{"EVENT", "SUPERVISOR_STATE_CHANGE"},
-	"SUPERVISOR_STATE_CHANGE_STOPPING": []string{"EVENT", "SUPERVISOR_STATE_CHANGE"},
-	"TICK_5":                []string{"EVENT", "TICK"},
-	"TICK_60":               []string{"EVENT", "TICK"},
-	"TICK_3600":             []string{"EVENT", "TICK"},
-	"PROCESS_GROUP_ADDED":   []string{"EVENT", "PROCESS_GROUP"},
-	"PROCESS_GROUP_REMOVED": []string{"EVENT", "PROCESS_GROUP"}}
-var eventSerial uint64 = 0
+	"PROCESS_STATE_STARTING":           {"EVENT", "PROCESS_STATE"},
+	"PROCESS_STATE_RUNNING":            {"EVENT", "PROCESS_STATE"},
+	"PROCESS_STATE_BACKOFF":            {"EVENT", "PROCESS_STATE"},
+	"PROCESS_STATE_STOPPING":           {"EVENT", "PROCESS_STATE"},
+	"PROCESS_STATE_EXITED":             {"EVENT", "PROCESS_STATE"},
+	"PROCESS_STATE_STOPPED":            {"EVENT", "PROCESS_STATE"},
+	"PROCESS_STATE_FATAL":              {"EVENT", "PROCESS_STATE"},
+	"PROCESS_STATE_UNKNOWN":            {"EVENT", "PROCESS_STATE"},
+	"REMOTE_COMMUNICATION":             {"EVENT"},
+	"PROCESS_LOG_STDOUT":               {"EVENT", "PROCESS_LOG"},
+	"PROCESS_LOG_STDERR":               {"EVENT", "PROCESS_LOG"},
+	"PROCESS_COMMUNICATION_STDOUT":     {"EVENT", "PROCESS_COMMUNICATION"},
+	"PROCESS_COMMUNICATION_STDERR":     {"EVENT", "PROCESS_COMMUNICATION"},
+	"SUPERVISOR_STATE_CHANGE_RUNNING":  {"EVENT", "SUPERVISOR_STATE_CHANGE"},
+	"SUPERVISOR_STATE_CHANGE_STOPPING": {"EVENT", "SUPERVISOR_STATE_CHANGE"},
+	"TICK_5":                {"EVENT", "TICK"},
+	"TICK_60":               {"EVENT", "TICK"},
+	"TICK_3600":             {"EVENT", "TICK"},
+	"PROCESS_GROUP_ADDED":   {"EVENT", "PROCESS_GROUP"},
+	"PROCESS_GROUP_REMOVED": {"EVENT", "PROCESS_GROUP"}}
+var eventSerial uint64
 var eventListenerManager = NewEventListenerManager()
 var eventPoolSerial = NewEventPoolSerial()
 
@@ -315,7 +313,7 @@ func (em *EventListenerManager) registerEventListener(eventListenerName string,
 			}
 		}
 	}
-	for event, _ := range all_events {
+	for event := range all_events {
 		log.WithFields(log.Fields{"eventListener": eventListenerName, "event": event}).Info("register event listener")
 		if _, ok := em.eventListeners[event]; !ok {
 			em.eventListeners[event] = make(map[*EventListener]bool)
@@ -354,7 +352,7 @@ func (em *EventListenerManager) EmitEvent(event Event) {
 	listeners, ok := em.eventListeners[event.GetType()]
 	if ok {
 		log.WithFields(log.Fields{"event": event.GetType()}).Info("process event")
-		for listener, _ := range listeners {
+		for listener := range listeners {
 			log.WithFields(log.Fields{"eventListener": listener.pool, "event": event.GetType()}).Info("receive event on listener")
 			listener.HandleEvent(event)
 		}
diff --git a/events/events_test.go b/events/events_test.go
@@ -40,14 +40,14 @@ func readEvent(reader *bufio.Reader) (string, string) {
 	header, err := reader.ReadString('\n')
 	if err != nil {
 		return "", ""
-	} else {
-		tmp := strings.Split(header[0:len(header)-1], ":")
-		len, _ := strconv.Atoi(tmp[len(tmp)-1])
-		b := make([]byte, len)
-		io.ReadFull(reader, b)
-		return header, string(b)
 	}
+	tmp := strings.Split(header[0:len(header)-1], ":")
+	len, _ := strconv.Atoi(tmp[len(tmp)-1])
+	b := make([]byte, len)
+	io.ReadFull(reader, b)
+	return header, string(b)
 }
+
 func TestEventListener(t *testing.T) {
 	r1, w1 := io.Pipe()
 	r2, w2 := io.Pipe()
diff --git a/logger/log.go b/logger/log.go
@@ -312,19 +312,17 @@ func (l *FileLogger) Close() error {
 
 func (sl *SysLogger) Write(b []byte) (int, error) {
 	sl.logEventEmitter.emitLogEvent(string(b))
-	if sl.logWriter != nil {
-		return sl.logWriter.Write(b)
-	} else {
+	if sl.logWriter == nil {
 		return 0, errors.New("not connect to syslog server")
 	}
+	return sl.logWriter.Write(b)
 }
 
 func (sl *SysLogger) Close() error {
-	if sl.logWriter != nil {
-		return sl.logWriter.Close()
-	} else {
+	if sl.logWriter == nil {
 		return errors.New("not connect to syslog server")
 	}
+	return sl.logWriter.Close()
 }
 func NewNullLogger(logEventEmitter LogEventEmitter) *NullLogger {
 	return &NullLogger{logEventEmitter: logEventEmitter}
diff --git a/pidproxy/pidproxy.go b/pidproxy/pidproxy.go
@@ -11,14 +11,14 @@ import (
 
 func installSignalAndForward(pidfile string, exitIfDaemonStopped bool) {
 	c := make(chan os.Signal, 1)
-	install_signal( c )
+	install_signal(c)
 
 	timer := time.After(5 * time.Second)
 	for {
 		select {
 		case sig := <-c:
 			fmt.Printf("Get a signal %v\n", sig)
-			if allowForwardSig( sig ) {
+			if allowForwardSig(sig) {
 				forwardSignal(sig, pidfile)
 			}
 
@@ -75,11 +75,10 @@ func readPid(pidfile string) (int, error) {
 		pid := 0
 		n, err := fmt.Fscanf(file, "%d", &pid)
 		if err == nil {
-			if n == 1 {
-				return pid, nil
-			} else {
+			if n != 1 {
 				return pid, errors.New("Fail to get pid from file")
 			}
+			return pid, nil
 		}
 	}
 	return 0, err
diff --git a/pidproxy/signal.go b/pidproxy/signal.go
@@ -2,15 +2,13 @@
 
 package main
 
-
 import (
 	"os"
 	"os/signal"
 	"syscall"
 )
 
-
-func install_signal( c chan os.Signal ) {
+func install_signal(c chan os.Signal) {
 	signal.Notify(c, syscall.SIGTERM,
 		syscall.SIGHUP,
 		syscall.SIGINT,
@@ -20,7 +18,6 @@ func install_signal( c chan os.Signal ) {
 		syscall.SIGCHLD)
 }
 
-func allowForwardSig( sig os.Signal ) bool {
+func allowForwardSig(sig os.Signal) bool {
 	return sig != syscall.SIGCHLD
 }
-
diff --git a/pidproxy/signal_windows.go b/pidproxy/signal_windows.go
@@ -8,14 +8,13 @@ import (
 	"syscall"
 )
 
-func install_signal( c chan os.Signal ) {
+func install_signal(c chan os.Signal) {
 	signal.Notify(c, syscall.SIGTERM,
 		syscall.SIGHUP,
 		syscall.SIGINT,
 		syscall.SIGQUIT)
 }
 
-func allowForwardSig( _ os.Signal ) bool {
+func allowForwardSig(_ os.Signal) bool {
 	return true
 }
-
diff --git a/process/path.go b/process/path.go
@@ -27,8 +27,8 @@ func Path_expand(path string) (string, error) {
 	pathList := path_split(path)
 
 	if len(pathList) > 0 && len(pathList[0]) > 0 && pathList[0][0] == '~' {
-		var usr *user.User = nil
-		var err error = nil
+		var usr *user.User
+		var err error
 
 		if pathList[0] == "~" {
 			usr, err = user.Current()
diff --git a/process/pdeathsig_windows.go b/process/pdeathsig_windows.go
@@ -1,4 +1,5 @@
 // +build windows
+
 package process
 
 import (
diff --git a/process/process.go b/process/process.go
diff --git a/process/process_manager.go b/process/process_manager.go
diff --git a/supervisor.go b/supervisor.go
diff --git a/types/comm-types.go b/types/comm-types.go
diff --git a/xmlrpc.go b/xmlrpc.go
diff --git a/xmlrpcclient/xmlrpc-client.go b/xmlrpcclient/xmlrpc-client.go

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+[![Go Report Card](https://goreportcard.com/badge/github.com/ochinchina/supervisord)](https://goreportcard.com/report/github.com/ochinchina/supervisord)`
	`2`	`+`
`1`	`3`	`# Why this project?`
`2`	`4`
`3`	`5`	`The python script supervisord is a powerful tool used by a lot of guys to manage the processes. I like the tool supervisord also.`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ func (pg *ProcessGroup) GetAllGroup() []string {`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`result := make([]string, 0)`
`62`		`- for group, _ := range groups {`
	`62`	`+ for group := range groups {`
`63`	`63`	`result = append(result, group)`
`64`	`64`	`}`
`65`	`65`	`return result`
Original file line number	Diff line number	Diff line change
`@@ -98,7 +98,7 @@ func NewTcpChecker(host string, port int, includes []string, timeout int) *TcpCh`
`98`	`98`	`func (tc *TcpChecker) start() {`
`99`	`99`	`go func() {`
`100`	`100`	`b := make([]byte, 1024)`
`101`		`- var err error = nil`
	`101`	`+ var err error`
`102`	`102`	`for {`
`103`	`103`	`tc.conn, err = net.Dial("tcp", fmt.Sprintf("%s:%d", tc.host, tc.port))`
`104`	`104`	`if err == nil \|\| tc.baseChecker.timeoutTime.Before(time.Now()) {`
`@@ -145,5 +145,4 @@ func (hc *HttpChecker) Check() bool {`
`145`	`145`	`}`
`146`	`146`	`}`
`147`	`147`	`}`
`148`		`- return false`
`149`	`148`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,8 +3,8 @@`
`3`	`3`	`package main`
`4`	`4`
`5`	`5`	`import (`
	`6`	`+ daemon "github.com/sevlyar/go-daemon"`
`6`	`7`	`log "github.com/sirupsen/logrus"`
`7`		`- "github.com/sevlyar/go-daemon"`
`8`	`8`	`)`
`9`	`9`
`10`	`10`	`func Deamonize(proc func()) {`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`		`-package main`
`2`		`-`
`3`	`1`	`// +build windows`
`4`	`2`
	`3`	`+package main`
	`4`	`+`
`5`	`5`	`func Deamonize(proc func()) {`
`6`	`6`	`proc()`
`7`	`7`	`}`