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,36 @@
+package parser
+
+import (
+	"log"
+	"regexp"
+	"strings"
+)
+
+type cronLine struct {
+	string
+}
+
+func (l cronLine) exportEnv() map[string]string {
+	match := envRegex.FindStringSubmatch(l.string)
+	answer := make(map[string]string)
+	switch len(match) {
+	case 0:
+	case 3:
+		answer[match[1]] = match[2]
+	default:
+		log.Panicf("found multiple(%d) env vars in single line\n please attach your crontab file too\n affected line: %s\n parser result: %#v\n", len(match), l.string, match)
+	}
+	return answer
+}
+
+func (l cronLine) exportSpec(regex *regexp.Regexp, env map[string]string, parser cronSpecParser) *cronSpec {
+	match := regex.FindStringSubmatch(l.string)
+	if len(match) < 1 {
+		if len(strings.Trim(l.string, " \n\t")) == 0 {
+			return nil
+		} else {
+			log.Panicf("cannot parse this non-empty line as cron specification: %s", l.string)
+		}
+	}
+	return parser(match, env)
+}

cmd/parser/cron_parser.go

@@ -0,0 +1,13 @@
+package parser
+
+import (
+	"github.com/FMotalleb/crontab-go/config"
+)
+
+func (cfg parserConfig) parse() config.Config {
+	cron := NewCronFromFile(cfg.cronFile)
+	return *cron.ParseConfig(
+		cfg.cronMatcher,
+		cfg.hasUser,
+	)
+}

cmd/parser/cron_spec.go

@@ -0,0 +1,50 @@
+package parser
+
+import (
+	"log"
+	"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 {
+	cronIndex := regex.SubexpIndex("cron")
+	// userIndex := regex.SubexpIndex("user")
+	cmdIndex := regex.SubexpIndex("cmd")
+	if cronIndex < 0 || cmdIndex < 0 {
+		log.Panicf("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,
+		}
+	}
+}
+
+func withUserParser(regex *regexp.Regexp) cronSpecParser {
+	cronIndex := regex.SubexpIndex("cron")
+	userIndex := regex.SubexpIndex("user")
+	cmdIndex := regex.SubexpIndex("cmd")
+	if cronIndex < 0 || cmdIndex < 0 || userIndex < 0 {
+		log.Panicf("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,
+		}
+	}
+}

cmd/parser/cron_string.go

@@ -0,0 +1,170 @@
+package parser
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"regexp"
+	"strings"
+
+	"github.com/FMotalleb/crontab-go/config"
+)
+
+var envRegex = regexp.MustCompile(`^(?<key>[\w\d_]+)=(?<value>.*)$`)
+
+type CronString struct {
+	string
+}
+
+func NewCronString(cron string) CronString {
+	return CronString{cron}
+}
+
+func NewCronFromFile(filePath string) CronString {
+	file, err := os.OpenFile(filePath, os.O_RDONLY, 0o644)
+	if err != nil {
+		log.Panicf("can't open cron file: %v", err)
+	}
+	stat, err := file.Stat()
+	if err != nil {
+		log.Panicf("can't stat cron file: %v", err)
+	}
+	content := make([]byte, stat.Size())
+	_, err = file.Read(content)
+	if err != nil {
+		log.Panicf("can't open cron file: %v", err)
+	}
+	return CronString{string(content)}
+}
+
+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 {
+	envTable := make(map[string]string)
+	specs := make([]cronSpec, 0)
+	lines := s.sanitize().lines()
+	matcher, parser := buildMapper(hasUser, pattern)
+
+	for _, line := range lines {
+		l := cronLine{line}
+		if env := l.exportEnv(); len(env) > 0 {
+			for key, val := range l.exportEnv() {
+				if old, ok := envTable[key]; ok {
+					log.Printf("env var of key `%s`, value `%s`, is going to be replaced by `%s`\n", key, old, val)
+				}
+				envTable[key] = val
+
+			}
+		} else {
+			if spec := l.exportSpec(matcher, envTable, parser); spec != nil {
+				specs = append(specs, *spec)
+			}
+		}
+	}
+	return specs
+}
+
+func (s *CronString) ParseConfig(
+	pattern string,
+	hasUser bool,
+) *config.Config {
+	specs := s.parseAsSpec(pattern, hasUser)
+	cfg := &config.Config{}
+	for _, spec := range specs {
+		addSpec(cfg, spec)
+	}
+	return cfg
+}
+
+func buildMapper(hasUser bool, pattern string) (*regexp.Regexp, func([]string, map[string]string) *cronSpec) {
+	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 {
+		log.Panicf("cannot parse cron `%s`", matcher)
+	}
+	var parser cronSpecParser
+	if hasUser {
+		parser = withUserParser(matcher)
+	} else {
+		parser = normalParser(matcher)
+	}
+	return matcher, parser
+}
+
+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/parser.go

@@ -0,0 +1,65 @@
+// Package parser manages holds the logic behind the sub command `parse`
+// this package is responsible for parsing a crontab file into valid config yaml file
+package parser
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"io"
+	"log"
+	"os"
+
+	"github.com/spf13/cobra"
+	"gopkg.in/yaml.v3"
+)
+
+var (
+	cfg       = &parserConfig{}
+	ParserCmd = &cobra.Command{
+		Use:       "parse <crontab file path>",
+		ValidArgs: []string{"crontab file path"},
+		Short:     "Parse crontab syntax and converts it into yaml syntax for crontab-go",
+		Run: func(cmd *cobra.Command, args []string) {
+			cfg.cronFile = cmd.Flags().Arg(0)
+			log.SetPrefix("[Cron Parser]")
+			if cfg.cronFile == "" {
+				log.Panicln(errors.New("no crontab file specified, see usage using --help flag"))
+			}
+			finalConfig := cfg.parse()
+			str, err := json.Marshal(finalConfig)
+			if err != nil {
+				log.Panicf("failed to marshal final config: %v", err)
+			}
+			hashMap := make(map[string]any)
+			if err := json.Unmarshal(str, &hashMap); err != nil {
+				log.Panicf("failed to unmarshal final config: %v", err)
+			}
+			ans, err := yaml.Marshal(hashMap)
+			if err != nil {
+				log.Panicf("failed to marshal final config: %v", err)
+			}
+			result := string(ans)
+			log.Printf("output:\n%s", result)
+			if cfg.output != "" {
+				outputFile, err := os.OpenFile(cfg.output, os.O_WRONLY|os.O_CREATE, 0o644)
+				if err != nil {
+					log.Panicf("failed to open output file: %v", err)
+				}
+				buf := bytes.NewBufferString(result)
+				_, err = io.Copy(outputFile, buf)
+				if err != nil {
+					log.Panicf("failed to write output file: %v", err)
+				}
+			}
+			log.Println("Done writing output")
+			os.Exit(0)
+		},
+	}
+)
+
+func init() {
+	ParserCmd.PersistentFlags().StringVarP(&cfg.output, "output", "o", "", "output file to write configuration to")
+	ParserCmd.PersistentFlags().BoolVarP(&cfg.hasUser, "with-user", "u", false, "indicates that whether the given cron file has user field")
+	ParserCmd.PersistentFlags().StringVar(&cfg.cronMatcher, "matcher", `(@(annually|yearly|monthly|weekly|daily|hourly|reboot))|(@every (\d+(ns|us|µs|ms|s|m|h))+)|((((\d+,)+\d+|(\d+(\/|-)\d+)|\d+|\*|(\*\/\d)) ?){5,7})`, "matcher for cron")
+}