grim/convey

even more linting

2018-02-19, Gary Kramlich
71cc01d7f292
Parents 9a4c9b8fe65a
Children 384f73205039
even more linting
2 files changed, 77 insertions(+), 30 deletions(-)
  • +45 -14
    plans/plans.go
  • +32 -16
    stages/stages.go
    • --- a/plans/plans.go Mon Feb 19 01:40:03 2018 -0600
    +++ b/plans/plans.go Mon Feb 19 01:54:43 2018 -0600
    @@ -47,34 +47,57 @@
    func (p *Plan) setup(logger *gomol.LogAdapter, st *state.State) error {
    // create the network
    - logger.Info("creating network...")
    + if lErr := logger.Info("creating network..."); lErr != nil {
    + fmt.Printf("error reporting info: %s\n", lErr)
    + }
    +
    network, err := docker.NewNetwork(st)
    if err != nil {
    - logger.Fatal("failed to create network")
    + if lErr := logger.Fatal("failed to create network"); lErr != nil {
    + fmt.Printf("error reporting fatal: %s\n", lErr)
    + }
    return err
    }
    +
    st.Network = network
    - logger.Infof("created network %s", st.Network.Name())
    + if lErr := logger.Infof("created network %s", st.Network.Name()); lErr != nil {
    + fmt.Printf("error reporting info: %s\n", lErr)
    + }
    +
    st.Cleanup(func(logger *gomol.LogAdapter) {
    - logger.Infof("removing network %s", st.Network.Name())
    - if err := st.Network.Destroy(); err != nil {
    - logger.Fatalf("failed to remove network %s", st.Network.Name())
    + if lErr := logger.Infof("removing network %s", st.Network.Name()); lErr != nil {
    + fmt.Printf("error reporting info: %s\n", lErr)
    + }
    +
    + if netErr := st.Network.Destroy(); netErr != nil {
    + if lErr := logger.Fatalf("failed to remove network %s: %s", st.Network.Name(), netErr); lErr != nil {
    + fmt.Printf("error reporting fatal: %s\n", lErr)
    + }
    } else {
    - logger.Infof("removed network %s", st.Network.Name())
    + if lErr := logger.Infof("removed network %s", st.Network.Name()); lErr != nil {
    + fmt.Printf("error reporting info: %s\n", lErr)
    + }
    }
    })
    // create the workspace
    - logger.Info("creating workspace...")
    + if lErr := logger.Info("creating workspace..."); lErr != nil {
    + fmt.Printf("error reporting info: %s\n", lErr)
    + }
    +
    ws, err := docker.NewWorkspace(st)
    if err != nil {
    - logger.Fatal("failed to create workspace")
    + if lErr := logger.Fatal("failed to create workspace"); lErr != nil {
    + fmt.Printf("error reporting fatal: %s\n", lErr)
    + }
    return err
    }
    st.Workspace = ws
    - logger.Infof("created workspace %s", st.Workspace.Name())
    + if lErr := logger.Infof("created workspace %s", st.Workspace.Name()); lErr != nil {
    + fmt.Printf("error reporting info: %s\n", lErr)
    + }
    return nil
    }
    @@ -97,11 +120,15 @@
    stageLogger := logging.NewAdapter(absStageName)
    if stage.ShouldRun(planErr) {
    - stageLogger.Info("stage starting")
    + if lErr := stageLogger.Info("stage starting"); lErr != nil {
    + fmt.Printf("error reporting info: %s\n", lErr)
    + }
    err := stage.Execute(absStageName, stageLogger, tasks, planEnv, st)
    if err != nil {
    - stageLogger.Fatal("stage failed")
    + if lErr := stageLogger.Fatal("stage failed"); lErr != nil {
    + fmt.Printf("error reporting fatal: %s\n", lErr)
    + }
    planErr = err
    @@ -110,9 +137,13 @@
    elapsed := time.Since(start)
    st.PlanTimeout -= elapsed
    - logger.Debugf("remaining plantime: %s", st.PlanTimeout)
    + if lErr := logger.Debugf("remaining plantime: %s", st.PlanTimeout); lErr != nil {
    + fmt.Printf("error reporting debug: %s\n", lErr)
    + }
    - stageLogger.Infof("stage finished [%s]", elapsed.Round(10*time.Millisecond))
    + if lErr := stageLogger.Infof("stage finished [%s]", elapsed.Round(10*time.Millisecond)); lErr != nil {
    + fmt.Printf("error reporting info: %s\n", lErr)
    + }
    }
    }
    --- a/stages/stages.go Mon Feb 19 01:40:03 2018 -0600
    +++ b/stages/stages.go Mon Feb 19 01:54:43 2018 -0600
    @@ -31,15 +31,21 @@
    "bitbucket.org/rw_grim/convey/yaml"
    )
    +const (
    + runAlways = "always"
    + runOnFailure = "on-failure"
    + runOnSuccess = "on-success"
    +)
    +
    // Stage is a representation of a stage.
    type Stage struct {
    Name string `yaml:"name"`
    + Run string `yaml:"run"`
    + Environment yaml.StringOrSlice `yaml:"environment"`
    + Tasks yaml.StringOrSlice `yaml:"tasks"`
    Enabled bool `yaml:"enabled"`
    Always bool `yaml:"always"`
    - Run string `yaml:"run"`
    Concurrent bool `yaml:"concurrent"`
    - Environment yaml.StringOrSlice `yaml:"environment"`
    - Tasks yaml.StringOrSlice `yaml:"tasks"`
    }
    // UnmarshalYAML is a custom yaml unmarshaller for stages.
    @@ -57,9 +63,9 @@
    if s.Run == "" {
    // If the always attribute is set, convert it to run syntax
    if s.Always {
    - s.Run = "always"
    + s.Run = runAlways
    } else {
    - s.Run = "on-success"
    + s.Run = runOnSuccess
    }
    } else {
    s.Run = strings.ToLower(s.Run)
    @@ -67,9 +73,9 @@
    // now validate the run attribute
    switch s.Run {
    - case "on-success":
    - case "on-failure":
    - case "always":
    + case runOnSuccess:
    + case runOnFailure:
    + case runAlways:
    default:
    return fmt.Errorf("Invalid value '%s' for run attribute", s.Run)
    }
    @@ -136,22 +142,32 @@
    func (s *Stage) runTask(path, name string, stageEnv []string, taskMap map[string]tasks.Task, st *state.State) error {
    absTaskName := fmt.Sprintf("%s/%s", path, name)
    taskLogger := logging.NewAdapter(fmt.Sprintf("%s/%s", path, name))
    - taskLogger.Info("starting")
    +
    + if lErr := taskLogger.Info("starting"); lErr != nil {
    + fmt.Printf("error reporting info: %s\n", lErr)
    + }
    task, found := taskMap[name]
    if !found {
    - taskLogger.Fatal("failed, task not found")
    + if lErr := taskLogger.Fatal("failed, task not found"); lErr != nil {
    + fmt.Printf("error reporting fatal: %s\n", lErr)
    + }
    return fmt.Errorf("task %s not found", absTaskName)
    }
    err := task.Execute(absTaskName, taskLogger, stageEnv, st)
    if err != nil {
    - taskLogger.Fatalf("failed, %s", err)
    + if lErr := taskLogger.Fatalf("failed, %s", err); lErr != nil {
    + fmt.Printf("error reporting fatal: %s\n", lErr)
    + }
    return err
    }
    - taskLogger.Info("finished")
    +
    + if lErr := taskLogger.Info("finished"); lErr != nil {
    + fmt.Printf("error reporting info: %s\n", lErr)
    + }
    return nil
    }
    @@ -159,17 +175,17 @@
    // ShouldRun will return True if a stage should be run based on the passed in
    // error (from the plan) and whether or not the stage is enabled.
    func (s *Stage) ShouldRun(err error) bool {
    - if s.Enabled == false {
    + if !s.Enabled {
    return false
    }
    - if s.Run == "always" {
    + if s.Run == runAlways {
    return true
    }
    if err != nil {
    - return s.Run == "on-failure"
    + return s.Run == runOnFailure
    }
    - return s.Run == "on-success"
    + return s.Run == runOnSuccess
    }