wip

.golangci.yml

@@ -11,6 +11,9 @@ linters-settings:
     min-occurrences: 5
   lll:
     line-length: 120
+  funlen:
+    lines: 80
+    statements: 45
   gomoddirectives:
     replace-local: true
   govet:

pkg/modgearman/command.go

@@ -32,7 +32,7 @@ type command struct {
 	InternalCheck InternalCheck
 }
 
-func parseCommand(rawCommand string, config *configurationStruct) *command {
+func parseCommand(rawCommand string, config *config) *command {
 	parsed := &command{
 		ExecType: Shell,
 		Command:  rawCommand,

pkg/modgearman/command_test.go

@@ -8,7 +8,7 @@ import (
 
 func TestCommandParser_1(t *testing.T) {
 	cmdLine := "/bin/command"
-	cmd := parseCommand(cmdLine, &configurationStruct{})
+	cmd := parseCommand(cmdLine, &config{})
 	assert.Equal(t, Exec, cmd.ExecType)
 	assert.Equal(t, "/bin/command", cmd.Command)
 	assert.Equal(t, []string{}, cmd.Args)
@@ -17,7 +17,7 @@ func TestCommandParser_1(t *testing.T) {
 
 func TestCommandParser_2(t *testing.T) {
 	cmdLine := "/bin/command args1"
-	cmd := parseCommand(cmdLine, &configurationStruct{})
+	cmd := parseCommand(cmdLine, &config{})
 	assert.Equal(t, Exec, cmd.ExecType)
 	assert.Equal(t, "/bin/command", cmd.Command)
 	assert.Equal(t, []string{"args1"}, cmd.Args)
@@ -26,7 +26,7 @@ func TestCommandParser_2(t *testing.T) {
 
 func TestCommandParser_3(t *testing.T) {
 	cmdLine := `ENV1='var' ./bin/command "args 123" "TEST"`
-	cmd := parseCommand(cmdLine, &configurationStruct{})
+	cmd := parseCommand(cmdLine, &config{})
 	assert.Equal(t, Exec, cmd.ExecType)
 	assert.Equal(t, "./bin/command", cmd.Command)
 	assert.Equal(t, []string{"args 123", "TEST"}, cmd.Args)
@@ -35,7 +35,7 @@ func TestCommandParser_3(t *testing.T) {
 
 func TestCommandParser_3b(t *testing.T) {
 	cmdLine := `ENV1='var space' ./bin/command "args 123" "TEST"`
-	cmd := parseCommand(cmdLine, &configurationStruct{})
+	cmd := parseCommand(cmdLine, &config{})
 	assert.Equal(t, Exec, cmd.ExecType)
 	assert.Equal(t, "./bin/command", cmd.Command)
 	assert.Equal(t, []string{"args 123", "TEST"}, cmd.Args)
@@ -45,7 +45,7 @@ func TestCommandParser_3b(t *testing.T) {
 // unparsable trailing quotes -> shell
 func TestCommandParser_4(t *testing.T) {
 	cmdLine := `ENV1='var' ./bin/command "args 123" "TEST`
-	cmd := parseCommand(cmdLine, &configurationStruct{})
+	cmd := parseCommand(cmdLine, &config{})
 	assert.Equal(t, Shell, cmd.ExecType)
 	assert.Equal(t, "/bin/sh", cmd.Command)
 	assert.Equal(t, []string{"-c", cmdLine}, cmd.Args)
@@ -54,7 +54,7 @@ func TestCommandParser_4(t *testing.T) {
 
 func TestCommandParser_5(t *testing.T) {
 	cmdLine := `trap 'echo Booh!' SIGINT SIGTERM; sleep 2`
-	cmd := parseCommand(cmdLine, &configurationStruct{})
+	cmd := parseCommand(cmdLine, &config{})
 	assert.Equal(t, Shell, cmd.ExecType)
 	assert.Equal(t, "/bin/sh", cmd.Command)
 	assert.Equal(t, []string{"-c", cmdLine}, cmd.Args)
@@ -63,7 +63,7 @@ func TestCommandParser_5(t *testing.T) {
 
 func TestCommandParser_BackslashDouble(t *testing.T) {
 	cmdLine := `test.sh "\t\n"`
-	cmd := parseCommand(cmdLine, &configurationStruct{})
+	cmd := parseCommand(cmdLine, &config{})
 	assert.Equal(t, Exec, cmd.ExecType)
 	assert.Equal(t, "test.sh", cmd.Command)
 	assert.Equal(t, []string{`\t\n`}, cmd.Args)
@@ -72,7 +72,7 @@ func TestCommandParser_BackslashDouble(t *testing.T) {
 
 func TestCommandParser_BackslashSingle(t *testing.T) {
 	cmdLine := `test.sh '\t\n'`
-	cmd := parseCommand(cmdLine, &configurationStruct{})
+	cmd := parseCommand(cmdLine, &config{})
 	assert.Equal(t, Exec, cmd.ExecType)
 	assert.Equal(t, "test.sh", cmd.Command)
 	assert.Equal(t, []string{`\t\n`}, cmd.Args)

pkg/modgearman/configuration_parser.go

@@ -11,7 +11,7 @@ import (
 	"strings"
 )
 
-type configurationStruct struct {
+type config struct {
 	binary                    string
 	build                     string
 	identifier                string
@@ -79,7 +79,7 @@ type configurationStruct struct {
 }
 
 // setDefaultValues sets reasonable defaults
-func (config *configurationStruct) setDefaultValues() {
+func (config *config) setDefaultValues() {
 	config.logmode = "automatic"
 	config.encryption = true
 	config.showErrorOutput = true
@@ -118,7 +118,7 @@ func (config *configurationStruct) setDefaultValues() {
 }
 
 // removeDuplicates removes duplicate entries from all string lists
-func (config *configurationStruct) removeDuplicates() {
+func (config *config) removeDuplicates() {
 	config.server = removeDuplicateStrings(config.server)
 	config.dupserver = removeDuplicateStrings(config.dupserver)
 	config.hostgroups = removeDuplicateStrings(config.hostgroups)
@@ -127,7 +127,7 @@ func (config *configurationStruct) removeDuplicates() {
 }
 
 // dump logs all config items
-func (config *configurationStruct) dump() {
+func (config *config) dump() {
 	logger.Debugf("binary                        %s\n", config.binary)
 	logger.Debugf("build                         %s\n", config.build)
 	logger.Debugf("identifier                    %s\n", config.identifier)
@@ -182,7 +182,7 @@ func (config *configurationStruct) dump() {
 }
 
 // parses the key value pairs and stores them in the configuration struct
-func (config *configurationStruct) parseConfigItem(raw string) error {
+func (config *config) parseConfigItem(raw string) error {
 	values := strings.SplitN(raw, "=", 2)
 	if len(values) <= 1 {
 		return fmt.Errorf("parse error, expected key=value in %s", raw)
@@ -348,7 +348,7 @@ func (config *configurationStruct) parseConfigItem(raw string) error {
 }
 
 // read settings from file or folder
-func (config *configurationStruct) readSettingsPath(path string) error {
+func (config *config) readSettingsPath(path string) error {
 	fileInfo, err := os.Stat(path)
 	if err != nil {
 		return fmt.Errorf("cannot read %s: %s", path, err.Error())
@@ -376,7 +376,7 @@ func (config *configurationStruct) readSettingsPath(path string) error {
 
 // opens the config file and reads all key value pairs, separated through = and commented out with #
 // also reads the config files specified in the config= value
-func (config *configurationStruct) readSettingsFile(path string) error {
+func (config *config) readSettingsFile(path string) error {
 	file, err := os.Open(path)
 	if err != nil {
 		return fmt.Errorf("cannot read file %s: %s", path, err.Error())
@@ -419,6 +419,7 @@ func getInt(input string) int {
 		logger.Debugf("Error converting %s to int, try with float", input)
 		result = int(getFloat(input))
 	}
+
 	return result
 }
 
@@ -431,13 +432,15 @@ func getFloat(input string) float64 {
 		logger.Errorf("error Converting %s to float", input)
 		result = 0
 	}
+
 	return result
 }
 
 func getBool(input string) bool {
 	if input == "yes" || input == "on" || input == "1" {
 		return true
 	}
+
 	return false
 }
 
@@ -451,6 +454,7 @@ func fixGearmandServerAddress(address string) string {
 	if len(parts) == 2 && parts[0] == "" {
 		return "0.0.0.0:" + parts[1]
 	}
+
 	return address
 }
 
@@ -464,5 +468,6 @@ func removeDuplicateStrings(elements []string) []string {
 			uniq = append(uniq, elements[v])
 		}
 	}
+
 	return uniq
 }

pkg/modgearman/configuration_parser_test.go

@@ -6,7 +6,7 @@ import (
 )
 
 func TestReadSettingsFile(t *testing.T) {
-	var testConfig configurationStruct
+	var testConfig config
 
 	// set default values so we can check if they get overwritten
 	testConfig.setDefaultValues()
@@ -59,7 +59,7 @@ server=hostname2
 }
 
 func TestReadSettingsPath(t *testing.T) {
-	var testConfig configurationStruct
+	var testConfig config
 
 	// set default values so we can check if they get overwritten
 	testConfig.setDefaultValues()

pkg/modgearman/decrypt.go

@@ -55,8 +55,10 @@ func createCipher(key []byte, encrypt bool) cipher.Block {
 		if err != nil {
 			logger.Panic(err)
 		}
+
 		return newCipher
 	}
+
 	return nil
 }
 
@@ -67,6 +69,7 @@ func createCipher(key []byte, encrypt bool) cipher.Block {
  */
 func decodeBase64(data string) []byte {
 	decodedBase, _ := b64.StdEncoding.DecodeString(data)
+
 	return decodedBase
 }
 
@@ -123,6 +126,7 @@ func parseTimeStringToFloat64(input string) float64 {
 	if err != nil {
 		return 0
 	}
+
 	return floatValue
 }
 
@@ -146,5 +150,6 @@ func createMap(input []byte) map[string]string {
 			resultMap[access[0]] = access[1]
 		}
 	}
+
 	return resultMap
 }

pkg/modgearman/decrypt_test.go

@@ -22,7 +22,7 @@ func TestCreateMap(t *testing.T) {
 }
 
 func TestDecrypt(t *testing.T) {
-	config := configurationStruct{}
+	config := config{}
 	config.encryption = true
 	config.key = "LaDPjcEqfZuKnUJStXHX27bxkHLAHSbD"
 	key := getKey(&config)

pkg/modgearman/dupserver.go

@@ -10,12 +10,12 @@ type dupServerConsumer struct {
 	queue              chan *answer
 	address            string
 	terminationRequest chan bool
-	config             *configurationStruct
+	config             *config
 }
 
 var dupServerConsumers map[string]*dupServerConsumer
 
-func initializeDupServerConsumers(config *configurationStruct) {
+func initializeDupServerConsumers(config *config) {
 	if len(config.dupserver) > 0 {
 		dupServerConsumers = make(map[string]*dupServerConsumer)
 		for _, dupAddress := range config.dupserver {
@@ -42,6 +42,7 @@ func terminateDupServerConsumers() bool {
 	}
 	logger.Debugf("Completed all consumer termination")
 	dupServerConsumers = nil
+
 	return true
 }
 
@@ -56,6 +57,7 @@ func runDupServerConsumer(dupServer *dupServerConsumer) {
 			if client != nil {
 				client.Close()
 			}
+
 			return
 		case item = <-dupServer.queue:
 			for {
@@ -65,29 +67,29 @@ func runDupServerConsumer(dupServer *dupServerConsumer) {
 					logger.Debugf("failed to send back result (to dupserver): %w", err)
 					select {
 					case <-dupServer.terminationRequest:
-						if client != nil {
-							client.Close()
-						}
 						return
 					default:
 						time.Sleep(ConnectionRetryInterval * time.Second)
+
 						continue
 					}
 				}
+
 				break
 			}
 		}
 	}
 }
 
-func sendResultDup(client *client.Client, item *answer, dupAddress string, config *configurationStruct) (*client.Client, error) {
+func sendResultDup(client *client.Client, item *answer, dupAddress string, config *config) (*client.Client, error) {
 	if config.dupResultsArePassive {
 		item.active = "passive"
 	}
+
 	return sendAnswer(client, item, dupAddress, config.encryption)
 }
 
-func enqueueDupServerResult(config *configurationStruct, result *answer) {
+func enqueueDupServerResult(config *config, result *answer) {
 	if len(config.dupserver) == 0 {
 		return
 	}
@@ -98,7 +100,10 @@ func enqueueDupServerResult(config *configurationStruct, result *answer) {
 		select {
 		case channel <- &duplicateResult:
 		default:
-			logger.Debugf("channel is at capacity (%d), dropping message (to dupserver): %s", config.dupServerBacklogQueueSize, dupAddress)
+			logger.Debugf("channel is at capacity (%d), dropping message (to dupserver): %s",
+				config.dupServerBacklogQueueSize,
+				dupAddress,
+			)
 		}
 	}
 }

pkg/modgearman/encrypt.go

@@ -8,6 +8,7 @@ const EncryptionBlockSize = 16
 
 func createAnswer(value *answer, withEncrypt bool) []byte {
 	encrypted := encrypt([]byte(value.String()), withEncrypt)
+
 	return encodeBase64(encrypted)
 }
 
@@ -43,5 +44,6 @@ func encrypt(data []byte, encrypt bool) []byte {
  */
 func encodeBase64(data []byte) []byte {
 	encodedBase := b64.StdEncoding.EncodeToString(data)
+
 	return []byte(encodedBase)
 }

pkg/modgearman/encrypt_test.go

@@ -11,7 +11,7 @@ func TestEncodeBase64(t *testing.T) {
 }
 
 func TestEncrypt(t *testing.T) {
-	config := configurationStruct{}
+	config := config{}
 	config.key = "LaDPjcEqfZuKnUJStXHX27bxkHLAHSbD"
 	config.encryption = true
 	myCipher = createCipher(getKey(&config), config.encryption)