yaml "github.com/zrepl/yaml-config"

"github.com/zrepl/zrepl/internal/client/status/viewmodel/stringbuilder"

"github.com/zrepl/zrepl/internal/daemon"

"github.com/zrepl/zrepl/internal/config"

"github.com/zrepl/zrepl/internal/daemon/job"

"github.com/zrepl/zrepl/internal/daemon/pruner"

"github.com/zrepl/zrepl/internal/daemon/snapper"

// filter out internal jobs

var jobsList []*Job

for _, j := range m.jobsList {

if daemon.IsInternalJobName(j.name) {

if config.IsInternalJobName(j.name) {

continue

}

jobsList = append(jobsList, j)

"os"

pathpkg "path"

"path/filepath"

"strings"

"time"

"github.com/pkg/errors"

return nil, err

}

if err = validateJobNames(rootConfig); err != nil {

return nil, err

}

return rootConfig, err

}

func IsInternalJobName(s string) bool {

return strings.HasPrefix(s, "_")

}

func validateJobNames(config *Config) error {

seen := make(map[string]struct{})

for _, job := range config.Jobs {

name := job.Name()

if IsInternalJobName(name) {

return errors.Errorf("job name %q is reserved for internal use (starts with _)", name)

}

if _, ok := seen[name]; ok {

return errors.Errorf("duplicate job name %q", name)

}

seen[name] = struct{}{}

}

return nil

}

func expandConfigInclude(configPath string, config *Config) (err error) {

var includeConfigPaths []string

for _, path := range config.Include {

}

func TestInvalidSampleConfigsFailToParse(t *testing.T) {

paths, err := filepath.Glob("./samples/invalid/*/zrepl.yml")

require.NoError(t, err, "glob failed")

require.NotEmpty(t, paths, "no invalid sample configs found")

for _, p := range paths {

t.Run(p, func(t *testing.T) {

_, err := ParseConfig(p)

require.Error(t, err, "expected config %s to fail parsing", p)

t.Logf("config %s failed as expected: %v", p, err)

})

}

}

// template must be a template/text template with a single '{{ . }}' as placeholder for val

//

//nolint:deadcode,unused

jobs:

- type: snap

name: "my_job"

filesystems: {

"<": true,

}

snapshotting:

type: manual

pruning:

keep:

- type: last_n

count: 10

- type: snap

name: "my_job"

filesystems: {

"<": true,

}

snapshotting:

type: manual

pruning:

keep:

- type: last_n

count: 5

jobs:

- type: snap

name: "my_job"

filesystems: {

"<": true,

}

snapshotting:

type: manual

pruning:

keep:

- type: last_n

count: 5

jobs:

- type: snap

name: "my_job"

filesystems: {

"<": true,

}

snapshotting:

type: manual

pruning:

keep:

- type: last_n

count: 10

include:

- ./included.yml

jobs:

- type: snap

name: "_internal_job"

filesystems: {

"<": true,

}

snapshotting:

type: manual

pruning:

keep:

- type: last_n

count: 10

"fmt"

"os"

"os/signal"

"strings"

"sync"

"syscall"

"time"

})

for _, job := range confJobs {

if IsInternalJobName(job.Name()) {

if config.IsInternalJobName(job.Name()) {

panic(fmt.Sprintf("internal job name used for config job '%s'", job.Name())) //FIXME

}

}

jobNameControl = "_control"

)

func IsInternalJobName(s string) bool {

return strings.HasPrefix(s, "_")

}

func (s *jobs) start(ctx context.Context, j job.Job, internal bool) {

s.m.Lock()

defer s.m.Unlock()

ctx = logging.WithInjectedField(ctx, logging.JobField, j.Name())

jobName := j.Name()

if !internal && IsInternalJobName(jobName) {

// package `config` enforces these with clean errors, these are just assertions

if !internal && config.IsInternalJobName(jobName) {

panic(fmt.Sprintf("internal job name used for non-internal job %s", jobName))

}

if internal && !IsInternalJobName(jobName) {

if internal && !config.IsInternalJobName(jobName) {

panic(fmt.Sprintf("internal job does not use internal job name %s", jobName))

}

if _, ok := s.jobs[jobName]; ok {