Initial commit

vendor/github.com/hyperhq/libcompose/logger/color.go

@@ -0,0 +1,34 @@
+package logger
+
+import "fmt"
+
+var (
+	colorPrefix = make(chan string)
+)
+
+func generateColors() {
+	i := 0
+	colorOrder := []string{
+		"36",   // cyan
+		"33",   // yellow
+		"32",   // green
+		"35",   // magenta
+		"31",   // red
+		"34",   // blue
+		"36;1", // intense cyan
+		"33;1", // intense yellow
+		"32;1", // intense green
+		"35;1", // intense magenta
+		"31;1", // intense red
+		"34;1", // intense blue
+	}
+
+	for {
+		colorPrefix <- fmt.Sprintf("\033[%sm%%s |\033[0m", colorOrder[i])
+		i = (i + 1) % len(colorOrder)
+	}
+}
+
+func init() {
+	go generateColors()
+}

vendor/github.com/hyperhq/libcompose/logger/color_logger.go

@@ -0,0 +1,75 @@
+package logger
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+
+	"golang.org/x/crypto/ssh/terminal"
+)
+
+// ColorLoggerFactory implements logger.Factory interface using ColorLogger.
+type ColorLoggerFactory struct {
+	maxLength int
+	tty       bool
+}
+
+// ColorLogger implements logger.Logger interface with color support.
+type ColorLogger struct {
+	name        string
+	colorPrefix string
+	factory     *ColorLoggerFactory
+}
+
+// NewColorLoggerFactory creates a new ColorLoggerFactory.
+func NewColorLoggerFactory() *ColorLoggerFactory {
+	return &ColorLoggerFactory{
+		tty: terminal.IsTerminal(int(os.Stdout.Fd())),
+	}
+}
+
+// Create implements logger.Factory.Create.
+func (c *ColorLoggerFactory) Create(name string) Logger {
+	if c.maxLength < len(name) {
+		c.maxLength = len(name)
+	}
+
+	return &ColorLogger{
+		name:        name,
+		factory:     c,
+		colorPrefix: <-colorPrefix,
+	}
+}
+
+// Out implements logger.Logger.Out.
+func (c *ColorLogger) Out(bytes []byte) {
+	if len(bytes) == 0 {
+		return
+	}
+	logFmt, name := c.getLogFmt()
+	message := fmt.Sprintf(logFmt, name, string(bytes))
+	fmt.Print(message)
+}
+
+// Err implements logger.Logger.Err.
+func (c *ColorLogger) Err(bytes []byte) {
+	if len(bytes) == 0 {
+		return
+	}
+	logFmt, name := c.getLogFmt()
+	message := fmt.Sprintf(logFmt, name, string(bytes))
+	fmt.Fprint(os.Stderr, message)
+}
+
+func (c *ColorLogger) getLogFmt() (string, string) {
+	pad := c.factory.maxLength
+
+	logFmt := "%s | %s"
+	if c.factory.tty {
+		logFmt = c.colorPrefix + " %s"
+	}
+
+	name := fmt.Sprintf("%-"+strconv.Itoa(pad)+"s", c.name)
+
+	return logFmt, name
+}

vendor/github.com/hyperhq/libcompose/logger/null.go

@@ -0,0 +1,18 @@
+package logger
+
+// NullLogger is a logger.Logger and logger.Factory implementation that does nothing.
+type NullLogger struct {
+}
+
+// Out is a no-op function.
+func (n *NullLogger) Out(_ []byte) {
+}
+
+// Err is a no-op function.
+func (n *NullLogger) Err(_ []byte) {
+}
+
+// Create implements logger.Factory and returns a NullLogger.
+func (n *NullLogger) Create(_ string) Logger {
+	return &NullLogger{}
+}

vendor/github.com/hyperhq/libcompose/logger/types.go

@@ -0,0 +1,29 @@
+package logger
+
+// Factory defines methods a factory should implement, to create a Logger
+// based on the specified name.
+type Factory interface {
+	Create(name string) Logger
+}
+
+// Logger defines methods to implement for being a logger.
+type Logger interface {
+	Out(bytes []byte)
+	Err(bytes []byte)
+}
+
+// Wrapper is a wrapper around Logger that implements the Writer interface,
+// mainly use by docker/pkg/stdcopy functions.
+type Wrapper struct {
+	Err    bool
+	Logger Logger
+}
+
+func (l *Wrapper) Write(bytes []byte) (int, error) {
+	if l.Err {
+		l.Logger.Err(bytes)
+	} else {
+		l.Logger.Out(bytes)
+	}
+	return len(bytes), nil
+}