commands: add streaming output

cmd/apply.go

@@ -19,6 +19,8 @@ import (
 	"fmt"
 	"os"
 
+	"golang.org/x/net/context"
+
 	"github.com/Sirupsen/logrus"
 	"github.com/asteris-llc/converge/exec"
 	"github.com/asteris-llc/converge/load"
@@ -42,6 +44,11 @@ var applyCmd = &cobra.Command{
 			logrus.WithError(err).Fatal("could not load params")
 		}
 
+		// set up execution context
+		ctx, cancel := context.WithCancel(context.Background())
+		GracefulExit(cancel)
+
+		// iterate over modules
 		for _, fname := range args {
 			logger := logrus.WithField("filename", fname)
 
@@ -50,18 +57,35 @@ var applyCmd = &cobra.Command{
 				logger.WithError(err).Fatal("could not parse file")
 			}
 
-			plan, err := exec.Plan(graph)
+			planStatus := make(chan *exec.StatusMessage, 1)
+			go func() {
+				for msg := range planStatus {
+					logger.WithField("path", msg.Path).Info(msg.Status)
+				}
+				close(planStatus)
+			}()
+
+			plan, err := exec.PlanWithStatus(ctx, graph, planStatus)
 			if err != nil {
 				logger.WithError(err).Fatal("planning failed")
 			}
 
-			results, err := exec.Apply(graph, plan)
+			status := make(chan *exec.StatusMessage, 1)
+			go func() {
+				for msg := range status {
+					logger.WithField("path", msg.Path).Info(msg.Status)
+				}
+				close(status)
+			}()
+
+			results, err := exec.ApplyWithStatus(ctx, graph, plan, status)
 			if err != nil {
 				logger.WithError(err).Fatal("applying failed")
 			}
 
 			var failed bool
 
+			fmt.Print("\n")
 			for _, result := range results {
 				if !result.Success {
 					failed = true

cmd/graceful_exit.go

@@ -0,0 +1,46 @@
+// Copyright © 2016 Asteris, LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cmd
+
+import (
+	"os"
+	"os/signal"
+
+	"github.com/Sirupsen/logrus"
+
+	"golang.org/x/net/context"
+)
+
+// GracefulExit traps interrupt signals for a graceful exit
+func GracefulExit(cancel context.CancelFunc) {
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, os.Interrupt)
+	go func() {
+		interruptCount := 0
+
+		for range c {
+			interruptCount++
+
+			switch interruptCount {
+			case 1:
+				logrus.Info("gracefully shutting down (interrupt again to halt)")
+				cancel()
+			case 2:
+				logrus.Warn("hard stop! System may be in an incomplete state")
+				os.Exit(2)
+			}
+		}
+	}()
+}

cmd/plan.go

@@ -18,6 +18,8 @@ import (
 	"errors"
 	"fmt"
 
+	"golang.org/x/net/context"
+
 	"github.com/Sirupsen/logrus"
 	"github.com/asteris-llc/converge/exec"
 	"github.com/asteris-llc/converge/load"
@@ -41,6 +43,10 @@ var planCmd = &cobra.Command{
 			logrus.WithError(err).Fatal("could not load params")
 		}
 
+		// set up execution context
+		ctx, cancel := context.WithCancel(context.Background())
+		GracefulExit(cancel)
+
 		for _, fname := range args {
 			logger := logrus.WithField("filename", fname)
 
@@ -49,11 +55,20 @@ var planCmd = &cobra.Command{
 				logger.WithError(err).Fatal("could not parse file")
 			}
 
-			results, err := exec.Plan(graph)
+			status := make(chan *exec.StatusMessage, 1)
+			go func() {
+				for msg := range status {
+					logger.WithField("path", msg.Path).Info(msg.Status)
+				}
+				close(status)
+			}()
+
+			results, err := exec.PlanWithStatus(ctx, graph, status)
 			if err != nil {
 				logger.WithError(err).Fatal("planning failed")
 			}
 
+			fmt.Print("\n")
 			for _, result := range results {
 				fmt.Println(result)
 			}

exec/apply.go

@@ -18,6 +18,8 @@ import (
 	"fmt"
 	"sync"
 
+	"golang.org/x/net/context"
+
 	"github.com/asteris-llc/converge/load"
 	"github.com/asteris-llc/converge/resource"
 )
@@ -40,8 +42,8 @@ func (p *ApplyResult) String() string {
 	)
 }
 
-// Apply the operations to be performed
-func Apply(graph *load.Graph, plan []*PlanResult) (results []*ApplyResult, err error) {
+// ApplyWithStatus applies the operations checked in plan
+func ApplyWithStatus(ctx context.Context, graph *load.Graph, plan []*PlanResult, status chan<- *StatusMessage) (results []*ApplyResult, err error) {
 	// transform checks into something we can look up easily
 	planResults := map[string]*PlanResult{}
 	for _, result := range plan {
@@ -52,6 +54,12 @@ func Apply(graph *load.Graph, plan []*PlanResult) (results []*ApplyResult, err e
 	lock := new(sync.Mutex)
 
 	err = graph.Walk(func(path string, res resource.Resource) error {
+		select {
+		case <-ctx.Done():
+			return nil
+		default:
+		}
+
 		planResult, ok := planResults[path]
 		if !ok || !planResult.WillChange {
 			return nil
@@ -70,6 +78,12 @@ func Apply(graph *load.Graph, plan []*PlanResult) (results []*ApplyResult, err e
 			}
 		)
 
+		select {
+		case <-ctx.Done():
+			return nil
+		case status <- &StatusMessage{Path: path, Status: "applying"}:
+		}
+
 		result.NewStatus, result.Success, err = task.Apply()
 		if err != nil {
 			return err
@@ -84,3 +98,16 @@ func Apply(graph *load.Graph, plan []*PlanResult) (results []*ApplyResult, err e
 
 	return results, err
 }
+
+// Apply does the same thing as ApplyWithStatus, but drops all status messages
+func Apply(ctx context.Context, graph *load.Graph, plan []*PlanResult) (results []*ApplyResult, err error) {
+	status := make(chan *StatusMessage, 1)
+	defer close(status)
+	go func() {
+		for range status {
+			continue
+		}
+	}()
+
+	return ApplyWithStatus(ctx, graph, plan, status)
+}

exec/apply_test.go

@@ -17,6 +17,8 @@ package exec_test
 import (
 	"testing"
 
+	"golang.org/x/net/context"
+
 	"github.com/asteris-llc/converge/exec"
 	"github.com/asteris-llc/converge/helpers"
 	"github.com/asteris-llc/converge/load"
@@ -31,11 +33,11 @@ func TestApply(t *testing.T) {
 	graph, err := load.Load("../samples/basic.hcl", resource.Values{})
 	require.NoError(t, err)
 
-	plan, err := exec.Plan(graph)
+	plan, err := exec.Plan(context.Background(), graph)
 	assert.NoError(t, err)
 
 	helpers.InTempDir(t, func() {
-		results, err := exec.Apply(graph, plan)
+		results, err := exec.Apply(context.Background(), graph, plan)
 		assert.NoError(t, err)
 		assert.Equal(
 			t,

exec/plan.go

@@ -18,6 +18,8 @@ import (
 	"fmt"
 	"sync"
 
+	"golang.org/x/net/context"
+
 	"github.com/asteris-llc/converge/load"
 	"github.com/asteris-llc/converge/resource"
 )
@@ -38,11 +40,17 @@ func (p *PlanResult) String() string {
 	)
 }
 
-// Plan the operations to be performed
-func Plan(graph *load.Graph) (results []*PlanResult, err error) {
+// PlanWithStatus plans the operations to be performed and outputs status
+func PlanWithStatus(ctx context.Context, graph *load.Graph, status chan<- *StatusMessage) (results []*PlanResult, err error) {
 	lock := new(sync.Mutex)
 
 	err = graph.Walk(func(path string, res resource.Resource) error {
+		select {
+		case <-ctx.Done():
+			return nil
+		default:
+		}
+
 		monitor, ok := res.(resource.Monitor)
 		if !ok {
 			return nil
@@ -53,6 +61,12 @@ func Plan(graph *load.Graph) (results []*PlanResult, err error) {
 			result = &PlanResult{Path: path}
 		)
 
+		select {
+		case <-ctx.Done():
+			return nil
+		case status <- &StatusMessage{Path: path, Status: "checking status"}:
+		}
+
 		result.CurrentStatus, result.WillChange, err = monitor.Check()
 		if err != nil {
 			return err
@@ -67,3 +81,16 @@ func Plan(graph *load.Graph) (results []*PlanResult, err error) {
 
 	return results, err
 }
+
+// Plan does the same thing as PlanWithStatus, but drops all status messages
+func Plan(ctx context.Context, graph *load.Graph) (results []*PlanResult, err error) {
+	status := make(chan *StatusMessage, 1)
+	defer close(status)
+	go func() {
+		for range status {
+			continue
+		}
+	}()
+
+	return PlanWithStatus(ctx, graph, status)
+}

exec/plan_test.go

@@ -17,6 +17,8 @@ package exec_test
 import (
 	"testing"
 
+	"golang.org/x/net/context"
+
 	"github.com/asteris-llc/converge/exec"
 	"github.com/asteris-llc/converge/load"
 	"github.com/asteris-llc/converge/resource"
@@ -30,7 +32,7 @@ func TestPlan(t *testing.T) {
 	graph, err := load.Load("../samples/basic.hcl", resource.Values{})
 	require.NoError(t, err)
 
-	results, err := exec.Plan(graph)
+	results, err := exec.Plan(context.Background(), graph)
 	assert.NoError(t, err)
 	assert.Equal(
 		t,

exec/status.go

@@ -0,0 +1,27 @@
+// Copyright © 2016 Asteris, LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package exec
+
+import "fmt"
+
+// StatusMessage is returned as status for Plan and Apply
+type StatusMessage struct {
+	Path   string
+	Status string
+}
+
+func (s *StatusMessage) String() string {
+	return fmt.Sprintf("%s: %s", s.Path, s.Status)
+}