Wrap errors in ctl/*.go

ctl/backup.go

@@ -16,12 +16,12 @@ package ctl
 
 import (
 	"context"
-	"errors"
 	"io"
 	"os"
 
 	"github.com/pilosa/pilosa"
 	"github.com/pilosa/pilosa/server"
+	"github.com/pkg/errors"
 )
 
 // BackupCommand represents a command for backing up a view.
@@ -60,26 +60,26 @@ func (cmd *BackupCommand) Run(ctx context.Context) error {
 	// Create a client to the server.
 	client, err := CommandClient(cmd)
 	if err != nil {
-		return err
+		return errors.Wrap(err, "creating client")
 	}
 
 	// Open output file.
 	f, err := os.Create(cmd.Path)
 	if err != nil {
-		return err
+		return errors.Wrap(err, "creating file")
 	}
 	defer f.Close()
 
 	// Begin streaming backup.
 	if err := client.BackupTo(ctx, f, cmd.Index, cmd.Frame, cmd.View); err != nil {
-		return err
+		return errors.Wrap(err, "backing up")
 	}
 
 	// Sync & close file to ensure durability.
 	if err := f.Sync(); err != nil {
-		return err
+		return errors.Wrap(err, "syncing")
 	} else if err = f.Close(); err != nil {
-		return err
+		return errors.Wrap(err, "closing file")
 	}
 
 	return nil

ctl/bench.go

@@ -16,7 +16,6 @@ package ctl
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"io"
 	"math/rand"
@@ -25,6 +24,7 @@ import (
 	"github.com/pilosa/pilosa"
 	"github.com/pilosa/pilosa/internal"
 	"github.com/pilosa/pilosa/server"
+	"github.com/pkg/errors"
 )
 
 // BenchCommand represents a command for benchmarking index operations.
@@ -58,7 +58,7 @@ func (cmd *BenchCommand) Run(ctx context.Context) error {
 	// Create a client to the server.
 	client, err := CommandClient(cmd)
 	if err != nil {
-		return err
+		return errors.Wrap(err, "creating client")
 	}
 
 	switch cmd.Op {

ctl/bench_test.go

@@ -23,6 +23,7 @@ import (
 	"testing"
 
 	"github.com/pilosa/pilosa"
+	"github.com/pkg/errors"
 )
 
 func TestBenchCommand_InvalidOption(t *testing.T) {
@@ -31,7 +32,7 @@ func TestBenchCommand_InvalidOption(t *testing.T) {
 
 	cm := NewBenchCommand(stdin, stdout, stderr)
 	err := cm.Run(context.Background())
-	if err != pilosa.ErrHostRequired {
+	if errors.Cause(err) != pilosa.ErrHostRequired {
 		t.Fatalf("Expect err: %s, actual err: %s", pilosa.ErrHostRequired, err)
 	}
 

ctl/check.go

@@ -24,6 +24,7 @@ import (
 
 	"github.com/pilosa/pilosa"
 	"github.com/pilosa/pilosa/roaring"
+	"github.com/pkg/errors"
 )
 
 // CheckCommand represents a command for performing consistency checks on data files.
@@ -48,17 +49,17 @@ func (cmd *CheckCommand) Run(ctx context.Context) error {
 		switch filepath.Ext(path) {
 		case "":
 			if err := cmd.checkBitmapFile(path); err != nil {
-				return err
+				return errors.Wrap(err, "checking bitmap")
 			}
 
 		case ".cache":
 			if err := cmd.checkCacheFile(path); err != nil {
-				return err
+				return errors.Wrap(err, "checking cache")
 			}
 
 		case ".snapshotting":
 			if err := cmd.checkSnapshotFile(path); err != nil {
-				return err
+				return errors.Wrap(err, "checking snapshot")
 			}
 		}
 	}
@@ -71,26 +72,26 @@ func (cmd *CheckCommand) checkBitmapFile(path string) error {
 	// Open file handle.
 	f, err := os.Open(path)
 	if err != nil {
-		return err
+		return errors.Wrap(err, "opening file")
 	}
 	defer f.Close()
 
 	fi, err := f.Stat()
 	if err != nil {
-		return err
+		return errors.Wrap(err, "statting file")
 	}
 
 	// Memory map the file.
 	data, err := syscall.Mmap(int(f.Fd()), 0, int(fi.Size()), syscall.PROT_READ, syscall.MAP_SHARED)
 	if err != nil {
-		return err
+		return errors.Wrap(err, "mmapping")
 	}
 	defer syscall.Munmap(data)
 
 	// Attach the mmap file to the bitmap.
 	bm := roaring.NewBitmap()
 	if err := bm.UnmarshalBinary(data); err != nil {
-		return err
+		return errors.Wrap(err, "unmarshalling")
 	}
 
 	// Perform consistency check.

ctl/check_test.go

@@ -85,7 +85,7 @@ func TestCheckCommand_Run(t *testing.T) {
 	var buf bytes.Buffer
 	io.Copy(&buf, r)
 
-	if !strings.HasPrefix(err.Error(), "invalid roaring file") {
+	if !strings.HasPrefix(err.Error(), "checking bitmap: unmarshalling: invalid roaring file") {
 		t.Fatalf("expect error: invalid roaring file, actual: '%s'", err)
 	}
 	//	Todo: need correct roaring file for happy path

ctl/common.go

@@ -19,6 +19,7 @@ import (
 
 	"github.com/pilosa/pilosa"
 	"github.com/pilosa/pilosa/server"
+	"github.com/pkg/errors"
 	"github.com/spf13/pflag"
 )
 
@@ -42,7 +43,7 @@ func CommandClient(cmd CommandWithTLSSupport) (*pilosa.InternalHTTPClient, error
 	if tlsConfig.CertificatePath != "" && tlsConfig.CertificateKeyPath != "" {
 		cert, err := tls.LoadX509KeyPair(tlsConfig.CertificatePath, tlsConfig.CertificateKeyPath)
 		if err != nil {
-			return nil, err
+			return nil, errors.Wrap(err, "loading keypair")
 		}
 		TLSConfig = &tls.Config{
 			Certificates:       []tls.Certificate{cert},
@@ -51,7 +52,7 @@ func CommandClient(cmd CommandWithTLSSupport) (*pilosa.InternalHTTPClient, error
 	}
 	client, err := pilosa.NewInternalHTTPClient(cmd.TLSHost(), server.GetHTTPClient(TLSConfig))
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "getting internal client")
 	}
 	return client, err
 }

ctl/export.go

@@ -22,6 +22,7 @@ import (
 
 	"github.com/pilosa/pilosa"
 	"github.com/pilosa/pilosa/server"
+	"github.com/pkg/errors"
 )
 
 // ExportCommand represents a command for bulk exporting data from a server.
@@ -68,7 +69,7 @@ func (cmd *ExportCommand) Run(ctx context.Context) error {
 	if cmd.Path != "" {
 		f, err := os.Create(cmd.Path)
 		if err != nil {
-			return err
+			return errors.Wrap(err, "creating file")
 		}
 		defer f.Close()
 
@@ -78,7 +79,7 @@ func (cmd *ExportCommand) Run(ctx context.Context) error {
 	// Create a client to the server.
 	client, err := CommandClient(cmd)
 	if err != nil {
-		return err
+		return errors.Wrap(err, "creating client")
 	}
 
 	// Determine slice count.
@@ -90,21 +91,21 @@ func (cmd *ExportCommand) Run(ctx context.Context) error {
 	}
 
 	if err != nil {
-		return err
+		return errors.Wrap(err, "getting slice count")
 	}
 
 	// Export each slice.
 	for slice := uint64(0); slice <= maxSlices[cmd.Index]; slice++ {
 		logger.Printf("exporting slice: %d", slice)
 		if err := client.ExportCSV(ctx, cmd.Index, cmd.Frame, cmd.View, slice, w); err != nil {
-			return err
+			return errors.Wrap(err, "exporting")
 		}
 	}
 
 	// Close writer, if applicable.
 	if w, ok := w.(io.Closer); ok {
 		if err := w.Close(); err != nil {
-			return err
+			return errors.Wrap(err, "closing")
 		}
 	}
 

ctl/import.go

@@ -17,7 +17,6 @@ package ctl
 import (
 	"context"
 	"encoding/csv"
-	"errors"
 	"fmt"
 	"io"
 	"log"
@@ -28,6 +27,7 @@ import (
 
 	"github.com/pilosa/pilosa"
 	"github.com/pilosa/pilosa/server"
+	"github.com/pkg/errors"
 )
 
 // ImportCommand represents a command for bulk importing data.
@@ -94,14 +94,14 @@ func (cmd *ImportCommand) Run(ctx context.Context) error {
 	// Create a client to the server.
 	client, err := CommandClient(cmd)
 	if err != nil {
-		return err
+		return errors.Wrap(err, "creating client")
 	}
 	cmd.Client = client
 
 	if cmd.CreateSchema {
 		err := cmd.ensureSchema(ctx)
 		if err != nil {
-			return err
+			return errors.Wrap(err, "ensuring schema")
 		}
 	}
 
@@ -153,7 +153,7 @@ func (cmd *ImportCommand) bufferBits(ctx context.Context, path string) error {
 		// Open file for reading.
 		f, err := os.Open(path)
 		if err != nil {
-			return err
+			return errors.Wrap(err, "opening file")
 		}
 		defer f.Close()
 
@@ -173,7 +173,7 @@ func (cmd *ImportCommand) bufferBits(ctx context.Context, path string) error {
 		if err == io.EOF {
 			break
 		} else if err != nil {
-			return err
+			return errors.Wrap(err, "reading")
 		}
 
 		// Ignore blank rows.
@@ -243,7 +243,7 @@ func (cmd *ImportCommand) importBits(ctx context.Context, bits []pilosa.Bit) err
 
 		logger.Printf("importing slice: %d, n=%d", slice, len(bits))
 		if err := cmd.Client.Import(ctx, cmd.Index, cmd.Frame, slice, bits); err != nil {
-			return err
+			return errors.Wrap(err, "importing")
 		}
 	}
 
@@ -260,7 +260,7 @@ func (cmd *ImportCommand) bufferBitsK(ctx context.Context, path string) error {
 		// Open file for reading.
 		f, err := os.Open(path)
 		if err != nil {
-			return err
+			return errors.Wrap(err, "opening file")
 		}
 		defer f.Close()
 
@@ -280,7 +280,7 @@ func (cmd *ImportCommand) bufferBitsK(ctx context.Context, path string) error {
 		if err == io.EOF {
 			break
 		} else if err != nil {
-			return err
+			return errors.Wrap(err, "reading")
 		}
 
 		// Ignore blank rows.
@@ -340,7 +340,7 @@ func (cmd *ImportCommand) importBitsK(ctx context.Context, bits []pilosa.Bit) er
 
 	logger.Printf("importing keys: n=%d", len(bits))
 	if err := cmd.Client.ImportK(ctx, cmd.Index, cmd.Frame, bits); err != nil {
-		return err
+		return errors.Wrap(err, "importing keys")
 	}
 
 	return nil
@@ -356,7 +356,7 @@ func (cmd *ImportCommand) bufferFieldValues(ctx context.Context, path string) er
 		// Open file for reading.
 		f, err := os.Open(path)
 		if err != nil {
-			return err
+			return errors.Wrap(err, "opening file")
 		}
 		defer f.Close()
 
@@ -376,7 +376,7 @@ func (cmd *ImportCommand) bufferFieldValues(ctx context.Context, path string) er
 		if err == io.EOF {
 			break
 		} else if err != nil {
-			return err
+			return errors.Wrap(err, "reading")
 		}
 
 		// Ignore blank rows.
@@ -437,7 +437,7 @@ func (cmd *ImportCommand) importFieldValues(ctx context.Context, vals []pilosa.F
 
 		logger.Printf("importing slice: %d, n=%d", slice, len(vals))
 		if err := cmd.Client.ImportValue(ctx, cmd.Index, cmd.Frame, cmd.Field, slice, vals); err != nil {
-			return err
+			return errors.Wrap(err, "importing values")
 		}
 	}
 

ctl/inspect.go

@@ -26,6 +26,7 @@ import (
 
 	"github.com/pilosa/pilosa"
 	"github.com/pilosa/pilosa/roaring"
+	"github.com/pkg/errors"
 )
 
 // InspectCommand represents a command for inspecting fragment data files.
@@ -49,19 +50,19 @@ func (cmd *InspectCommand) Run(ctx context.Context) error {
 	// Open file handle.
 	f, err := os.Open(cmd.Path)
 	if err != nil {
-		return err
+		return errors.Wrap(err, "opening file")
 	}
 	defer f.Close()
 
 	fi, err := f.Stat()
 	if err != nil {
-		return err
+		return errors.Wrap(err, "statting file")
 	}
 
 	// Memory map the file.
 	data, err := syscall.Mmap(int(f.Fd()), 0, int(fi.Size()), syscall.PROT_READ, syscall.MAP_SHARED)
 	if err != nil {
-		return err
+		return errors.Wrap(err, "mmapping")
 	}
 	defer syscall.Munmap(data)
 
@@ -70,7 +71,7 @@ func (cmd *InspectCommand) Run(ctx context.Context) error {
 	fmt.Fprintf(cmd.Stderr, "unmarshaling bitmap...")
 	bm := roaring.NewBitmap()
 	if err := bm.UnmarshalBinary(data); err != nil {
-		return err
+		return errors.Wrap(err, "unmarshalling")
 	}
 	fmt.Fprintf(cmd.Stderr, " (%s)\n", time.Since(t))
 

ctl/restore.go

@@ -16,12 +16,12 @@ package ctl
 
 import (
 	"context"
-	"errors"
 	"io"
 	"os"
 
 	"github.com/pilosa/pilosa"
 	"github.com/pilosa/pilosa/server"
+	"github.com/pkg/errors"
 )
 
 // RestoreCommand represents a command for restoring a frame from a backup.
@@ -60,19 +60,19 @@ func (cmd *RestoreCommand) Run(ctx context.Context) error {
 	// Create a client to the server.
 	client, err := CommandClient(cmd)
 	if err != nil {
-		return err
+		return errors.Wrap(err, "creating client")
 	}
 
 	// Open backup file.
 	f, err := os.Open(cmd.Path)
 	if err != nil {
-		return err
+		return errors.Wrap(err, "opening file")
 	}
 	defer f.Close()
 
 	// Restore backup file to the cluster.
 	if err := client.RestoreFrom(ctx, f, cmd.Index, cmd.Frame, cmd.View); err != nil {
-		return err
+		return errors.Wrap(err, "restoring")
 	}
 
 	return nil