feat: cron parser

.vscode/launch.json

@@ -15,6 +15,19 @@
                 "-c",
                 "config.local.yaml"
             ]
-        }
+        },
+        {
+            "name": "Parse",
+            "type": "go",
+            "request": "launch",
+            "mode": "auto",
+            "program": ".",
+            "env": {},
+            "args": [
+                "parse",
+                "crontab.log",
+                "-u"
+            ]
+        },
     ]
 }

cmd/parser/config.go

@@ -0,0 +1,8 @@
+package parser
+
+type parserConfig struct {
+	cronFile    string
+	output      string
+	cronMatcher string
+	hasUser     bool
+}

cmd/parser/cron_line.go

@@ -0,0 +1,41 @@
+package parser
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+)
+
+type cronLine struct {
+	string
+}
+
+var envRegex = regexp.MustCompile(`^(?<key>[\w\d_]+)=(?<value>.*)$`)
+
+func (l cronLine) exportEnv() (map[string]string, error) {
+	match := envRegex.FindStringSubmatch(l.string)
+	answer := make(map[string]string)
+	switch len(match) {
+	case 0:
+	case 3:
+		answer[match[1]] = match[2]
+	default:
+		return nil, fmt.Errorf("unexpected response from environment parser for line:\n%s", l.string)
+	}
+	if len(answer) != 1 && len(strings.Trim(l.string, " \n\t")) != 0 {
+		return nil, fmt.Errorf("line cannot be parsed as environment:\n%s", l.string)
+	}
+	return answer, nil
+}
+
+func (l cronLine) exportSpec(regex *regexp.Regexp, env map[string]string, parser cronSpecParser) (*cronSpec, error) {
+	match := regex.FindStringSubmatch(l.string)
+	if len(match) < 1 {
+		if len(strings.Trim(l.string, " \n\t")) == 0 {
+			return nil, nil
+		} else {
+			return nil, fmt.Errorf("cannot parse this non-empty line as cron specification: %s", l.string)
+		}
+	}
+	return parser(match, env), nil
+}

cmd/parser/cron_line_test.go

@@ -0,0 +1,53 @@
+package parser
+
+import (
+	"testing"
+
+	"github.com/alecthomas/assert/v2"
+)
+
+func TestExportEnv_SingleMatch(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected map[string]string
+		wantErr  bool
+	}{
+		{
+			name:     "Single match",
+			input:    "MY_VAR=value",
+			expected: map[string]string{"MY_VAR": "value"},
+			wantErr:  false,
+		},
+		{
+			name:     "No match",
+			input:    "no_match",
+			expected: nil,
+			wantErr:  true,
+		},
+		{
+			name:     "Empty input",
+			input:    "",
+			expected: map[string]string{},
+			wantErr:  false,
+		},
+		{
+			name:     "Special characters",
+			input:    "VAR_WITH_UNDERSCORE=value_with_underscore",
+			expected: map[string]string{"VAR_WITH_UNDERSCORE": "value_with_underscore"},
+			wantErr:  false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			cl := cronLine{string: tt.input}
+			got, err := cl.exportEnv()
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				assert.Equal(t, tt.expected, got)
+			}
+		})
+	}
+}

cmd/parser/cron_spec.go

@@ -0,0 +1,50 @@
+package parser
+
+import (
+	"fmt"
+	"regexp"
+)
+
+type (
+	cronSpecParser = func([]string, map[string]string) *cronSpec
+	cronSpec       struct {
+		timing  string
+		user    string
+		command string
+		environ map[string]string
+	}
+)
+
+func normalParser(regex *regexp.Regexp) (cronSpecParser, error) {
+	cronIndex := regex.SubexpIndex("cron")
+	// userIndex := regex.SubexpIndex("user")
+	cmdIndex := regex.SubexpIndex("cmd")
+	if cronIndex < 0 || cmdIndex < 0 {
+		return nil, fmt.Errorf("cannot find groups (cron,cmd) in regexp: `%s", regex)
+	}
+	return func(match []string, env map[string]string) *cronSpec {
+		return &cronSpec{
+			timing:  match[cronIndex],
+			user:    "",
+			command: match[cmdIndex],
+			environ: env,
+		}
+	}, nil
+}
+
+func withUserParser(regex *regexp.Regexp) (cronSpecParser, error) {
+	cronIndex := regex.SubexpIndex("cron")
+	userIndex := regex.SubexpIndex("user")
+	cmdIndex := regex.SubexpIndex("cmd")
+	if cronIndex < 0 || cmdIndex < 0 || userIndex < 0 {
+		return nil, fmt.Errorf("cannot find groups (cron,user,cmd) in regexp: `%s", regex)
+	}
+	return func(match []string, env map[string]string) *cronSpec {
+		return &cronSpec{
+			timing:  match[cronIndex],
+			user:    match[userIndex],
+			command: match[cmdIndex],
+			environ: env,
+		}
+	}, nil
+}

cmd/parser/cron_string.go

@@ -0,0 +1,167 @@
+package parser
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+
+	"github.com/sirupsen/logrus"
+
+	"github.com/FMotalleb/crontab-go/config"
+)
+
+type CronString struct {
+	string
+}
+
+func NewCronString(cron string) CronString {
+	return CronString{cron}
+}
+
+func (s CronString) replaceAll(regex string, repl string) CronString {
+	reg := regexp.MustCompile(regex)
+	out := reg.ReplaceAllString(s.string, repl)
+	return CronString{out}
+}
+
+func (s CronString) sanitizeLineBreaker() CronString {
+	return s.replaceAll(
+		`\s*\\\s*\n\s*([\n|\n\s])*`,
+		" ",
+	)
+}
+
+func (s CronString) sanitizeEmptyLine() CronString {
+	return s.replaceAll(
+		`\n\s*\n`,
+		"\n",
+	)
+}
+
+func (s CronString) sanitizeComments() CronString {
+	return s.replaceAll(
+		`\s*#.*`,
+		"",
+	)
+}
+
+func (s CronString) sanitize() CronString {
+	return s.
+		replaceAll("\r\n", "\n").
+		sanitizeComments().
+		sanitizeLineBreaker().
+		sanitizeEmptyLine()
+}
+
+func (s CronString) lines() []string {
+	return strings.Split(s.string, "\n")
+}
+
+func (s *CronString) parseAsSpec(
+	pattern string,
+	hasUser bool,
+) ([]cronSpec, error) {
+	envTable := make(map[string]string)
+	specs := make([]cronSpec, 0)
+	lines := s.sanitize().lines()
+	matcher, parser, err := buildMapper(hasUser, pattern)
+	if err != nil {
+		return []cronSpec{}, err
+	}
+	for _, line := range lines {
+		l := cronLine{line}
+		if env, err := l.exportEnv(); len(env) > 0 {
+			if err != nil {
+				return nil, err
+			}
+			for key, val := range env {
+				if old, ok := envTable[key]; ok {
+					logrus.Warnf("env var of key `%s`, value `%s`, is going to be replaced by `%s`", key, old, val)
+				}
+				envTable[key] = val
+
+			}
+		} else {
+			spec, err := l.exportSpec(matcher, envTable, parser)
+			if err != nil {
+				return nil, err
+			}
+			if spec != nil {
+				specs = append(specs, *spec)
+			}
+
+		}
+	}
+	return specs, nil
+}
+
+func (s *CronString) ParseConfig(
+	pattern string,
+	hasUser bool,
+) (*config.Config, error) {
+	specs, err := s.parseAsSpec(pattern, hasUser)
+	if err != nil {
+		return nil, err
+	}
+	cfg := &config.Config{}
+	for _, spec := range specs {
+		addSpec(cfg, spec)
+	}
+	return cfg, nil
+}
+
+func buildMapper(hasUser bool, pattern string) (*regexp.Regexp, cronSpecParser, error) {
+	lineParser := "(?<cmd>.*)"
+	if hasUser {
+		lineParser = fmt.Sprintf(`(?<user>\w[\w\d]*)\s+%s`, lineParser)
+	}
+	cronLineMatcher := fmt.Sprintf(`^(?<cron>%s)\s+%s$`, pattern, lineParser)
+
+	matcher, err := regexp.Compile(cronLineMatcher)
+	if err != nil {
+		return nil, nil, fmt.Errorf("cannot parse cron `%s`", matcher)
+	}
+	var parser cronSpecParser
+	if hasUser {
+		parser, err = withUserParser(matcher)
+	} else {
+		parser, err = normalParser(matcher)
+	}
+	if err != nil {
+		return nil, nil, err
+	}
+	return matcher, parser, nil
+}
+
+func addSpec(cfg *config.Config, spec cronSpec) {
+	jobName := fmt.Sprintf("FromCron: %s", spec.timing)
+	for _, job := range cfg.Jobs {
+		if job.Name == jobName {
+			task := config.Task{
+				Command:  spec.command,
+				UserName: spec.user,
+				Env:      spec.environ,
+			}
+			job.Tasks = append(
+				job.Tasks,
+				task,
+			)
+			return
+		}
+	}
+	initJob(jobName, spec.timing, cfg)
+	addSpec(cfg, spec)
+}
+
+func initJob(jobName string, timing string, cfg *config.Config) {
+	job := &config.JobConfig{}
+	job.Name = jobName
+	job.Description = "Imported from cron file"
+	job.Disabled = false
+	job.Events = []config.JobEvent{
+		{
+			Cron: timing,
+		},
+	}
+	cfg.Jobs = append(cfg.Jobs, job)
+}

cmd/parser/helper.go

@@ -0,0 +1,27 @@
+package parser
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"gopkg.in/yaml.v3"
+
+	"github.com/FMotalleb/crontab-go/config"
+)
+
+func generateYamlFromCfg(finalConfig *config.Config) (string, error) {
+	str, err := json.Marshal(finalConfig)
+	if err != nil {
+		return "", fmt.Errorf("failed to marshal(json) final config: %v", err)
+	}
+	hashMap := make(map[string]any)
+	if err := json.Unmarshal(str, &hashMap); err != nil {
+		return "", fmt.Errorf("failed to unmarshal(json) final config: %v", err)
+	}
+	ans, err := yaml.Marshal(hashMap)
+	if err != nil {
+		return "", fmt.Errorf("failed to marshal(yaml) final config: %v", err)
+	}
+	result := string(ans)
+	return result, nil
+}