Merge pull request #425 from carlosms/go-cli

Migrate to src-d/go-cli and src-d/go-log

Author: carlosms

CHANGELOG.md

@@ -11,6 +11,21 @@
 
 - `bblfsh/bblfshd` has been updated to [v2.12.1-drivers](https://github.com/bblfsh/bblfshd/releases/tag/v2.12.1).
 
+### Breaking Changes
+
+- `srcd` commands do not have a `-v/--verbose` flag anymore, it has been replaced with the `--log-level=debug` option ([#410](https://github.com/src-d/engine/issues/410)).
+- The `srcd/cli-daemon` docker image executable now requires to use the `serve` sub command. This does not affect end users ([#410](https://github.com/src-d/engine/issues/410)).
+
+### New Features
+
+- The `srcd` commands now have the following new options for log messages ([#410](https://github.com/src-d/engine/issues/410)):
+```
+--log-level=[info|debug|warning|error] Logging level (default: info) [$LOG_LEVEL]
+--log-format=[text|json]               log format, defaults to text on a terminal and json otherwise [$LOG_FORMAT]
+--log-fields=                          default fields for the logger, specified in json [$LOG_FIELDS]
+--log-force-format                     ignore if it is running on a terminal or not [$LOG_FORCE_FORMAT]
+```
+
 </details>
 
 ## [v0.12.0](https://github.com/src-d/engine/releases/tag/v0.12.0) - 2019-04-04

api/config.go

@@ -1,8 +1,10 @@
 package api
 
 import (
-	"github.com/sirupsen/logrus"
+	"fmt"
+
 	"github.com/src-d/engine/components"
+
 	yaml "gopkg.in/yaml.v2"
 )
 
@@ -63,7 +65,7 @@ func (c *Config) SetDefaults() {
 func (c *Config) AsYaml() string {
 	bs, err := yaml.Marshal(c)
 	if err != nil {
-		logrus.Fatalf("Unable to marshal config to YAML: %v", err)
+		panic(fmt.Sprintf("Unable to marshal config to YAML: %v", err))
 	}
 	return string(bs)
 }

cmd/srcd-server/Dockerfile

@@ -9,7 +9,9 @@ ENV ROOTPATH=github.com/src-d/engine
 
 ADD . /go/src/${ROOTPATH}
 WORKDIR /go/src/${ROOTPATH}
-RUN TAG=$(git describe --tags) && go install -ldflags "-X main.version=${TAG}" "${ROOTPATH}/cmd/srcd-server"
+RUN TAG=$(git describe --tags) && \
+    BUILD=$(date +"%m-%d-%Y_%H_%M_%S") && \
+    go install -ldflags "-X main.version=${TAG} -X main.build=${BUILD}" "${ROOTPATH}/cmd/srcd-server"
 
 FROM alpine
 RUN apk update && \

cmd/srcd-server/engine/drivers.go

@@ -6,10 +6,10 @@ import (
 
 	drivers "github.com/bblfsh/bblfshd/daemon/protocol"
 	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
 	"github.com/src-d/engine/api"
 	"github.com/src-d/engine/components"
 	"google.golang.org/grpc"
+	"gopkg.in/src-d/go-log.v1"
 )
 
 var ErrDriverAlreadyInstalled = errors.New("driver already installed")
@@ -20,7 +20,7 @@ func (s *Server) bblfshDriverClient(ctx context.Context) (drivers.ProtocolServic
 	}
 
 	addr := fmt.Sprintf("%s:%d", bblfshd.Name, components.BblfshControlPort)
-	logrus.Infof("connecting to bblfsh management on %s", addr)
+	log.Infof("connecting to bblfsh management on %s", addr)
 	conn, err := grpc.Dial(addr, grpc.WithInsecure())
 	if err != nil {
 		return nil, errors.Wrap(err, "could not connect to bblfsh drivers")

cmd/srcd-server/engine/parse.go

@@ -10,12 +10,12 @@ import (
 	"github.com/bblfsh/go-client/v4/tools"
 	"github.com/docker/docker/api/types/container"
 	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
 	"github.com/src-d/engine/api"
 	"github.com/src-d/engine/components"
 	"github.com/src-d/engine/docker"
 	"gopkg.in/bblfsh/sdk.v2/uast/nodes"
 	enry "gopkg.in/src-d/enry.v1"
+	"gopkg.in/src-d/go-log.v1"
 )
 
 var bblfshd = components.Bblfshd
@@ -24,13 +24,13 @@ type logf func(format string, args ...interface{})
 
 func (s *Server) ParseWithLogs(req *api.ParseRequest, stream api.Engine_ParseWithLogsServer) error {
 	log := func(format string, args ...interface{}) {
-		logrus.Infof(format, args...)
+		log.Infof(format, args...)
 		err := stream.Send(&api.ParseResponse{
 			Kind: api.ParseResponse_LOG,
 			Log:  fmt.Sprintf(format, args...),
 		})
 		if err != nil {
-			logrus.Errorf("could not stream log: %v", err)
+			log.Errorf(err, "could not stream log")
 		}
 	}
 
@@ -42,7 +42,7 @@ func (s *Server) ParseWithLogs(req *api.ParseRequest, stream api.Engine_ParseWit
 }
 
 func (s *Server) Parse(ctx context.Context, req *api.ParseRequest) (*api.ParseResponse, error) {
-	return s.parse(ctx, req, logrus.Infof)
+	return s.parse(ctx, req, log.Infof)
 }
 
 func (s *Server) parse(ctx context.Context, req *api.ParseRequest, log logf) (*api.ParseResponse, error) {
@@ -118,7 +118,7 @@ func createBbblfshd(opts ...docker.ConfigOption) docker.StartFunc {
 			return err
 		}
 
-		logrus.Infof("starting bblfshd daemon")
+		log.Infof("starting bblfshd daemon")
 
 		ctx, cancel := context.WithTimeout(ctx, startComponentTimeout)
 		defer cancel()

cmd/srcd-server/engine/sql.go

@@ -9,10 +9,10 @@ import (
 	"github.com/docker/docker/api/types/container"
 	"github.com/go-sql-driver/mysql"
 	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
 	"github.com/src-d/engine/api"
 	"github.com/src-d/engine/components"
 	"github.com/src-d/engine/docker"
+	"gopkg.in/src-d/go-log.v1"
 )
 
 const (
@@ -37,7 +37,7 @@ func (s *Server) SQL(req *api.SQLRequest, stream api.Engine_SQLServer) error {
 		AllowNativePasswords: true,
 		MaxAllowedPacket:     32 << 20, // 32 MiB
 	}
-	logrus.Infof("connecting to mysql %q", cfg.FormatDSN())
+	log.Infof("connecting to mysql %q", cfg.FormatDSN())
 	db, err := sql.Open("mysql", cfg.FormatDSN())
 	if err != nil {
 		return errors.Wrap(err, "could not connect to gitbase")

cmd/srcd-server/engine/web.go

@@ -6,9 +6,9 @@ import (
 	"time"
 
 	"github.com/docker/docker/api/types/container"
-	"github.com/sirupsen/logrus"
 	"github.com/src-d/engine/components"
 	"github.com/src-d/engine/docker"
+	"gopkg.in/src-d/go-log.v1"
 )
 
 const gitbaseWebSelectLimit = 0
@@ -24,7 +24,7 @@ func createBblfshWeb(opts ...docker.ConfigOption) docker.StartFunc {
 			return err
 		}
 
-		logrus.Infof("starting bblfshd web")
+		log.Infof("starting bblfshd web")
 
 		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 		defer cancel()
@@ -51,7 +51,7 @@ func createGitbaseWeb(opts ...docker.ConfigOption) docker.StartFunc {
 			return err
 		}
 
-		logrus.Infof("starting gitbase web")
+		log.Infof("starting gitbase web")
 
 		ctx, cancel := context.WithTimeout(context.Background(), startComponentTimeout)
 		defer cancel()

cmd/srcd-server/main.go

@@ -1,57 +1,65 @@
 package main
 
 import (
+	"fmt"
 	"net"
 	"strings"
 
 	"github.com/src-d/engine/api"
 	"github.com/src-d/engine/cmd/srcd-server/engine"
 
-	flags "github.com/jessevdk/go-flags"
-	"github.com/sirupsen/logrus"
+	"github.com/pkg/errors"
 	grpc "google.golang.org/grpc"
+	"gopkg.in/src-d/go-cli.v0"
+	"gopkg.in/src-d/go-log.v1"
 	yaml "gopkg.in/yaml.v2"
 )
 
-var version = "undefined"
+// These variables get replaced during the build
+var (
+	version = "dev"
+	build   = "dev"
+)
 
 func main() {
-	var options struct {
-		Addr    string `long:"address" short:"a" default:"0.0.0.0:4242"`
-		Workdir string `long:"workdir" short:"w" default:""`
-		HostOS  string `long:"host-os" default:""`
-		Config  string `long:"config" short:"c" default:""`
-	}
+	cmd := cli.New("srcd-server", version, build, "The Code as Data solution by source{d}")
+	cmd.AddCommand(&serveCmd{})
 
-	_, err := flags.Parse(&options)
-	if err != nil {
-		logrus.Fatal(err)
-	}
+	cmd.RunMain()
+}
 
-	workdir := strings.TrimSpace(options.Workdir)
+type serveCmd struct {
+	cli.Command `name:"serve" short-description:"Start the server" long-description:"Start the server"`
+
+	Addr    string `long:"address" short:"a" default:"0.0.0.0:4242"`
+	Workdir string `long:"workdir" short:"w" default:""`
+	HostOS  string `long:"host-os" default:""`
+	Config  string `long:"config" short:"c" default:""`
+}
+
+func (c *serveCmd) Execute(args []string) error {
+	workdir := strings.TrimSpace(c.Workdir)
 	if workdir == "" {
-		logrus.Fatal("No work directory provided!")
+		return fmt.Errorf("No work directory provided!")
 	}
 
 	var config api.Config
-	if options.Config != "" {
-		err = yaml.Unmarshal([]byte(options.Config), &config)
+	if c.Config != "" {
+		err := yaml.Unmarshal([]byte(c.Config), &config)
 		if err != nil {
-			logrus.Fatalf("Error reading --config option: %s", err)
+			return errors.Wrapf(err, "Error reading --config option")
 		}
 	}
 	config.SetDefaults()
 
-	l, err := net.Listen("tcp", options.Addr)
+	l, err := net.Listen("tcp", c.Addr)
 	if err != nil {
-		logrus.Fatal(err)
+		return err
 	}
 
 	srv := grpc.NewServer()
-	api.RegisterEngineServer(srv, engine.NewServer(version, workdir, options.HostOS, config))
+	api.RegisterEngineServer(srv, engine.NewServer(version, workdir, c.HostOS, config))
 
-	logrus.Infof("listening on %s", options.Addr)
-	if err := srv.Serve(l); err != nil {
-		logrus.Fatal(err)
-	}
+	log.Infof("listening on %s", c.Addr)
+	return srv.Serve(l)
 }