feat: logger for output & errors

examples/host/main.go

@@ -3,8 +3,9 @@ package main
 import (
 	"log"
 
-	"github.com/aerogear/charmil/plugins/calculator"
-	"github.com/aerogear/charmil/plugins/hi"
+	"github.com/aerogear/charmil/examples/plugins/calculator"
+	"github.com/aerogear/charmil/examples/plugins/date"
+	"github.com/aerogear/charmil/pkg/factory"
 	"github.com/spf13/cobra"
 )
 
@@ -15,8 +16,12 @@ func main() {
 		SilenceUsage: true,
 	}
 
-	cmd.AddCommand(calculator.AddCommand)
-	cmd.AddCommand(hi.HiCommand)
+	// init default factory for the host
+	// pass to all the commands
+	defaultFactory := factory.Default()
+
+	cmd.AddCommand(calculator.RootCommand(defaultFactory))
+	cmd.AddCommand(date.DateCommand(defaultFactory))
 
 	if err := cmd.Execute(); err != nil {
 		log.Fatal(err)

examples/plugins/calculator/main.go

@@ -0,0 +1,73 @@
+package calculator
+
+import (
+	"strconv"
+
+	"github.com/aerogear/charmil/pkg/factory"
+	"github.com/aerogear/charmil/pkg/logging"
+	"github.com/spf13/cobra"
+)
+
+type Options struct {
+	Logger func() (logging.Logger, error)
+}
+
+func RootCommand(f *factory.Factory) *cobra.Command {
+	opts := &Options{
+		Logger: f.Logger,
+	}
+	cmd := &cobra.Command{
+		Use:          "calc",
+		Short:        "Calculator",
+		Example:      "$ host calc add 2 3",
+		SilenceUsage: true,
+	}
+
+	cmd.AddCommand(AddCmd(opts))
+	return cmd
+}
+
+func AddCmd(opts *Options) *cobra.Command {
+	addCmd := &cobra.Command{
+		Use:   "add",
+		Short: "Add numbers",
+		Long:  `Adding the numbers`,
+		Run: func(cmd *cobra.Command, args []string) {
+			fstatus, _ := cmd.Flags().GetBool("float")
+			if fstatus {
+				addFloat(args, opts)
+			} else {
+				addInt(args, opts)
+			}
+		},
+	}
+
+	addCmd.Flags().BoolP("float", "f", false, "Add Floating Numbers")
+	return addCmd
+}
+
+func addInt(args []string, opts *Options) {
+	logger, _ := opts.Logger()
+	var sum int
+	for _, ival := range args {
+		itemp, err := strconv.Atoi(ival)
+		if err != nil {
+			logger.Error(err)
+		}
+		sum = sum + itemp
+	}
+	logger.Output("Addition of numbers", args, "is", sum)
+}
+
+func addFloat(args []string, opts *Options) {
+	logger, _ := opts.Logger()
+	var sum float64
+	for _, fval := range args {
+		ftemp, err := strconv.ParseFloat(fval, 64)
+		if err != nil {
+			logger.Error(err)
+		}
+		sum = sum + ftemp
+	}
+	logger.Output("Addition of numbers", args, "is", sum)
+}

examples/plugins/date/main.go

@@ -0,0 +1,31 @@
+package date
+
+import (
+	"time"
+
+	"github.com/aerogear/charmil/pkg/factory"
+	"github.com/aerogear/charmil/pkg/logging"
+	"github.com/spf13/cobra"
+)
+
+type Options struct {
+	Logger func() (logging.Logger, error)
+}
+
+func DateCommand(f *factory.Factory) *cobra.Command {
+	opts := &Options{
+		Logger: f.Logger,
+	}
+	cmd := &cobra.Command{
+		Use:          "date",
+		Short:        "tell date",
+		Example:      "$ host date",
+		SilenceUsage: true,
+		Run: func(cmd *cobra.Command, args []string) {
+			logger, _ := opts.Logger()
+			logger.Output("Date Time is", time.Now())
+		},
+	}
+
+	return cmd
+}

pkg/factory/default.go

@@ -0,0 +1,32 @@
+package factory
+
+import (
+	"os"
+
+	"github.com/aerogear/charmil/pkg/logging"
+)
+
+// create new command factory
+func Default() *Factory {
+	var logger logging.Logger
+
+	loggerFunc := func() (logging.Logger, error) {
+		if logger != nil {
+			return logger, nil
+		}
+
+		loggerBuilder := logging.NewStdLoggerBuilder()
+		loggerBuilder = loggerBuilder.Streams(os.Stdout, os.Stdin)
+		logger, err := loggerBuilder.Build()
+
+		if err != nil {
+			return nil, err
+		}
+
+		return logger, nil
+	}
+
+	return &Factory{
+		Logger: loggerFunc,
+	}
+}

pkg/factory/factory.go

@@ -0,0 +1,10 @@
+package factory
+
+import (
+	"github.com/aerogear/charmil/pkg/logging"
+)
+
+// Access to all the commands
+type Factory struct {
+	Logger func() (logging.Logger, error)
+}

pkg/logging/logger.go

@@ -0,0 +1,6 @@
+package logging
+
+type Logger interface {
+	Output(args ...interface{})
+	Error(args ...interface{})
+}

pkg/logging/std_logger.go

@@ -0,0 +1,53 @@
+package logging
+
+import (
+	"fmt"
+	"io"
+	"os"
+)
+
+type StdLoggerBuilder struct {
+	outStream io.Writer
+	errStream io.Writer
+}
+
+type StdLogger struct {
+	outStream io.Writer
+	errStream io.Writer
+}
+
+// returns new StdLoggerBuilder object
+func NewStdLoggerBuilder() *StdLoggerBuilder {
+	builder := new(StdLoggerBuilder)
+	return builder
+}
+
+// Set input output streams
+func (b *StdLoggerBuilder) Streams(out io.Writer, err io.Writer) *StdLoggerBuilder {
+	b.outStream = out
+	b.errStream = err
+	return b
+}
+
+// builds a new logger with configuration stored in builder
+func (b *StdLoggerBuilder) Build() (logger *StdLogger, err error) {
+	logger = new(StdLogger)
+	logger.outStream = b.outStream
+	logger.errStream = b.errStream
+	if logger.outStream == nil {
+		logger.outStream = os.Stdout
+	}
+	if logger.errStream == nil {
+		logger.errStream = os.Stderr
+	}
+
+	return
+}
+
+func (l *StdLogger) Output(args ...interface{}) {
+	fmt.Fprintln(l.outStream, args...)
+}
+
+func (l *StdLogger) Error(args ...interface{}) {
+	fmt.Fprintln(l.errStream, args...)
+}