Remove juju/errors

antireplay/cache.go

 package antireplay
 
 import (
+	"errors"
+	"fmt"
+
 	"github.com/allegro/bigcache"
 
 	"github.com/9seconds/mtg/config"
 		HardMaxCacheSize: config.C.AntiReplay.MaxSize,
 	})
 	cache = c
+	err = fmt.Errorf("qqq: %w", errors.New("tt"))
 
 	return err
 }

cli/proxy.go

 	defer logger.Sync() // nolint: errcheck
 
 	if err := config.InitPublicAddress(ctx); err != nil {
-		Fatal(err.Error())
+		Fatal(err)
 	}
 	zap.S().Debugw("Configuration", "config", config.C)
 
 	PrintJSONStdout(config.GetURLs())
 
 	if err := antireplay.Init(); err != nil {
-		Fatal(err.Error())
+		Fatal(err)
 	}
 	if err := stats.Init(ctx); err != nil {
-		Fatal(err.Error())
+		Fatal(err)
 	}
 	proxyListener, err := net.Listen("tcp", config.C.ListenAddr.String())
 	if err != nil {
-		Fatal(err.Error())
+		Fatal(err)
 	}
 	go func() {
 		<-ctx.Done()

cli/utils.go

 	"os"
 )
 
-func Fatal(args ...interface{}) {
-	PrintStderr(args...)
+func Fatal(arg interface{}) {
+	if value, ok := arg.(error); ok {
+		arg = fmt.Errorf("fatal error: %+v", value)
+	}
+	PrintStderr(arg)
 	os.Exit(1)
 }
 

config/config.go

 	"bytes"
 	"context"
 	"encoding/json"
+	"errors"
+	"fmt"
 	"net"
 	"strconv"
 	"time"
 
-	"github.com/juju/errors"
 	"go.uber.org/zap"
 	statsd "gopkg.in/alexcesaro/statsd.v2"
 )
 			case "influxdb":
 				C.StatsdStats.TagsFormat = statsd.InfluxDB
 			default:
-				return errors.Errorf("Incorrect statsd tag %s", value)
+				return fmt.Errorf("Incorrect statsd tag %s", value)
 			}
 		case OptionTypeStatsdTags:
 			C.StatsdStats.Tags = opt.Value.(map[string]string)
 		case OptionTypeAdtag:
 			C.AdTag = opt.Value.([]byte)
 		default:
-			return errors.Errorf("Unknown tag %v", opt.Option)
+			return fmt.Errorf("Unknown tag %v", opt.Option)
 		}
 	}
 

config/global_ips.go

 
 import (
 	"context"
+	"fmt"
 	"io"
 	"io/ioutil"
 	"net"
 	"net/http"
 	"strings"
 	"time"
-
-	"github.com/juju/errors"
 )
 
 const (
 func getGlobalIPv4(ctx context.Context) (net.IP, error) {
 	ip, err := fetchIP(ctx, "tcp4")
 	if err != nil || ip.To4() == nil {
-		return nil, errors.Annotate(err, "Cannot find public ipv4 address")
+		return nil, fmt.Errorf("cannot find public ipv4 address: %w", err)
 	}
 	return ip, nil
 }
 func getGlobalIPv6(ctx context.Context) (net.IP, error) {
 	ip, err := fetchIP(ctx, "tcp6")
 	if err != nil || ip.To4() != nil {
-		return nil, errors.Annotate(err, "Cannot find public ipv6 address")
+		return nil, fmt.Errorf("cannot find public ipv6 address: %w", err)
 	}
 	return ip, nil
 }
 
 	req, err := http.NewRequest("GET", ifconfigAddress, nil)
 	if err != nil {
-		return nil, errors.Annotate(err, "Cannot create a request")
+		return nil, fmt.Errorf("cannot create a request: %w", err)
 	}
 
 	resp, err := client.Do(req.WithContext(ctx))
 		if resp != nil {
 			io.Copy(ioutil.Discard, resp.Body) // nolint: errcheck
 		}
-		return nil, errors.Annotate(err, "Cannot perform a request")
+		return nil, fmt.Errorf("cannot perform a request: %w", err)
 	}
 	defer resp.Body.Close() // nolint: errcheck
 
 	respDataBytes, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
-		return nil, errors.Annotate(err, "Cannot read response body")
+		return nil, fmt.Errorf("cannot read response body: %w", err)
 	}
 	respData := strings.TrimSpace(string(respDataBytes))
 
 	ip := net.ParseIP(respData)
 	if ip == nil {
-		return nil, errors.Errorf("ifconfig.co returns incorrect IP %s", respData)
+		return nil, fmt.Errorf("ifconfig.co returns incorrect IP %s", respData)
 	}
 
 	return ip, nil

go.mod

 	github.com/allegro/bigcache v1.2.1
 	github.com/beevik/ntp v0.2.0
 	github.com/cespare/xxhash v1.1.0
-	github.com/dustin/go-humanize v1.0.0
-	github.com/gofrs/uuid v3.2.0+incompatible
-	github.com/juju/errors v0.0.0-20190806202954-0232dcc7464d
-	github.com/juju/loggo v0.0.0-20190526231331-6e530bcce5d8 // indirect
-	github.com/juju/testing v0.0.0-20190723135506-ce30eb24acd2 // indirect
 	github.com/kr/pretty v0.1.0 // indirect
-	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
-	github.com/modern-go/reflect2 v1.0.1 // indirect
 	github.com/pkg/errors v0.8.1 // indirect
 	github.com/prometheus/client_golang v1.1.0
 	github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4 // indirect
 	github.com/spaolacci/murmur3 v1.1.0 // indirect
-	github.com/stretchr/testify v1.4.0
+	github.com/stretchr/testify v1.4.0 // indirect
 	go.uber.org/atomic v1.4.0 // indirect
 	go.uber.org/multierr v1.1.0 // indirect
 	go.uber.org/zap v1.10.0
 	gopkg.in/alecthomas/kingpin.v2 v2.2.6
 	gopkg.in/alexcesaro/statsd.v2 v2.0.0
 	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
-	gopkg.in/mgo.v2 v2.0.0-20190816093944-a6b53ec6cb22 // indirect
 )
+
+go 1.13

go.sum

 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo=
-github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
 github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/gofrs/uuid v3.2.0+incompatible h1:y12jRkkFxsd7GpqdSZ+/KCs/fJbqpEXSGd4+jfEaewE=
-github.com/gofrs/uuid v3.2.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
 github.com/gogo/protobuf v1.1.1 h1:72R+M5VuhED/KujmZVcIquuo8mBgX4oVda//DQb3PXo=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
 github.com/json-iterator/go v1.1.7/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
-github.com/juju/errors v0.0.0-20190806202954-0232dcc7464d h1:hJXjZMxj0SWlMoQkzeZDLi2cmeiWKa7y1B8Rg+qaoEc=
-github.com/juju/errors v0.0.0-20190806202954-0232dcc7464d/go.mod h1:W54LbzXuIE0boCoNJfwqpmkKJ1O4TCTZMetAt6jGk7Q=
-github.com/juju/loggo v0.0.0-20190526231331-6e530bcce5d8 h1:UUHMLvzt/31azWTN/ifGWef4WUqvXk0iRqdhdy/2uzI=
-github.com/juju/loggo v0.0.0-20190526231331-6e530bcce5d8/go.mod h1:vgyd7OREkbtVEN/8IXZe5Ooef3LQePvuBm9UWj6ZL8U=
-github.com/juju/testing v0.0.0-20190723135506-ce30eb24acd2 h1:Pp8RxiF4rSoXP9SED26WCfNB28/dwTDpPXS8XMJR8rc=
-github.com/juju/testing v0.0.0-20190723135506-ce30eb24acd2/go.mod h1:63prj8cnj0tU0S9OHjGJn+b1h0ZghCndfnbQolrYTwA=
 github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/mgo.v2 v2.0.0-20190816093944-a6b53ec6cb22 h1:VpOs+IwYnYBaFnrNAeB8UUWtL3vEUnzSCL1nVjPhqrw=
-gopkg.in/mgo.v2 v2.0.0-20190816093944-a6b53ec6cb22/go.mod h1:yeKp02qBN3iKW1OzL3MGk2IdtZzaj7SFntXj72NppTA=
 gopkg.in/yaml.v2 v2.2.1 h1:mUhvW9EsL+naU5Q3cakzfE91YhliOondGd6ZrsDBHQE=
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=

main.go

 	app.HelpFlag.Short('h')
 
 	if err := utils.SetLimits(); err != nil {
-		cli.Fatal(err.Error())
+		cli.Fatal(err)
 	}
 
 	switch kingpin.MustParse(app.Parse(os.Args[1:])) {
 			config.Opt{Option: config.OptionTypeAdtag, Value: *proxyAdtag},
 		)
 		if err != nil {
-			cli.Fatal(err.Error())
+			cli.Fatal(err)
 		}
 
 		if err := cli.Proxy(); err != nil {
-			cli.Fatal(err.Error())
+			cli.Fatal(err)
 		}
 	}
 }

ntp/ntp.go

 package ntp
 
 import (
+	"fmt"
 	"math/rand"
 	"time"
 
 	"github.com/beevik/ntp"
-	"github.com/juju/errors"
 	"go.uber.org/zap"
 )
 
 	url := ntpEndpoints[rand.Intn(len(ntpEndpoints))]
 	resp, err := ntp.Query(url)
 	if err != nil {
-		return 0, errors.Annotatef(err, "Cannot fetch NTP server %s", url)
+		return 0, fmt.Errorf("Cannot fetch NTP server %s: %w", url, err)
 	}
 
 	offsetInt := int64(resp.ClockOffset)

obfuscated2/client_protocol.go

 	"bytes"
 	"crypto/sha256"
 	"encoding/binary"
+	"errors"
+	"fmt"
 	"io"
 	"time"
 
-	"github.com/juju/errors"
-
 	"github.com/9seconds/mtg/antireplay"
 	"github.com/9seconds/mtg/config"
 	"github.com/9seconds/mtg/conntypes"
 func (c *ClientProtocol) Handshake(socket wrappers.StreamReadWriteCloser) (wrappers.StreamReadWriteCloser, error) {
 	fm, err := c.ReadFrame(socket)
 	if err != nil {
-		return nil, errors.Annotate(err, "Cannot make client handshake")
+		return nil, fmt.Errorf("cannot make a client handshake: %w", err)
 	}
 
 	decHasher := sha256.New()
 
 func (c *ClientProtocol) ReadFrame(socket wrappers.StreamReader) (fm Frame, err error) {
 	if _, err = io.ReadFull(handshakeReader{socket}, fm.Bytes()); err != nil {
-		err = errors.Annotate(err, "Cannot extract obfuscated2 frame")
+		err = fmt.Errorf("cannot extract obfuscated2 frame: %w", err)
 	}
 	return
 }

obfuscated2/telegram_protocol.go

 
 import (
 	"crypto/rand"
-
-	"github.com/juju/errors"
+	"fmt"
 
 	"github.com/9seconds/mtg/protocol"
 	"github.com/9seconds/mtg/telegram"
 		req.ClientProtocol.GetDC(),
 		req.ClientProtocol.GetConnectionProtocol())
 	if err != nil {
-		return nil, errors.Annotate(err, "Cannot dial to Telegram")
+		return nil, fmt.Errorf("cannot dial to telegram: %w", err)
 	}
 	fm := generateFrame(req.ClientProtocol)
 	data := fm.Bytes()
 	copy(data[:frameOffsetIV], copyFrame[:frameOffsetIV])
 
 	if _, err := socket.Write(data); err != nil {
-		return nil, errors.Annotate(err, "Cannot write handshate frame to Telegram")
+		return nil, fmt.Errorf("cannot write handshake frame to telegram: %w", err)
 	}
 
 	return wrappers.NewObfuscated2(socket, encryptor, decryptor), nil

stats/stats.go

 
 import (
 	"context"
+	"fmt"
 	"net"
 	"net/http"
 
-	"github.com/juju/errors"
-
 	"github.com/9seconds/mtg/config"
 	"github.com/9seconds/mtg/conntypes"
 )
 	instanceJSON := newStatsJSON(mux)
 	instancePrometheus, err := newStatsPrometheus(mux)
 	if err != nil {
-		return errors.Annotate(err, "Cannot initialize Prometheus")
+		return fmt.Errorf("cannot initialize prometheus: %w", err)
 	}
 
 	stats := []Stats{instanceJSON, instancePrometheus}
 	if config.C.StatsdStats.Addr.IP != nil {
 		instanceStatsd, err := newStatsStatsd()
 		if err != nil {
-			return errors.Annotate(err, "Cannot initialize StatsD")
+			return fmt.Errorf("cannot inialize statsd: %w", err)
 		}
 		stats = append(stats, instanceStatsd)
 	}
 
 	listener, err := net.Listen("tcp", config.C.StatsAddr.String())
 	if err != nil {
-		return errors.Annotate(err, "Cannot initialize stats server")
+		return fmt.Errorf("cannot initialize stats server: %w", err)
 	}
 
 	srv := http.Server{

stats/stats_prometheus.go

 package stats
 
 import (
+	"fmt"
 	"net"
 	"net/http"
 
-	"github.com/juju/errors"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 
 	}
 
 	if err := registry.Register(instance.connections); err != nil {
-		return nil, errors.Annotate(err, "Cannot register metrics for connections")
+		return nil, fmt.Errorf("cannot register metrics for connections: %w", err)
 	}
 	if err := registry.Register(instance.traffic); err != nil {
-		return nil, errors.Annotate(err, "Cannot register metrics for traffic")
+		return nil, fmt.Errorf("cannot register metrics for traffic: %w", err)
 	}
 	if err := registry.Register(instance.crashes); err != nil {
-		return nil, errors.Annotate(err, "Cannot register metrics for crashes")
+		return nil, fmt.Errorf("cannot register metrics for crashes: %w", err)
 	}
 	if err := registry.Register(instance.antiReplays); err != nil {
-		return nil, errors.Annotate(err, "Cannot register metrics for anti replays")
+		return nil, fmt.Errorf("cannot register metrics for anti replays: %w", err)
 	}
 
 	handler := promhttp.HandlerFor(registry, promhttp.HandlerOpts{})

stats/stats_statsd.go

 package stats
 
 import (
+	"fmt"
 	"net"
 	"strings"
 
-	"github.com/juju/errors"
 	"gopkg.in/alexcesaro/statsd.v2"
 
 	"github.com/9seconds/mtg/config"
 
 	client, err := statsd.New(options...)
 	if err != nil {
-		return nil, errors.Annotate(err, "Cannot initialize a client")
+		return nil, fmt.Errorf("cannot initialize a client: %w", err)
 	}
 
 	return &statsStatsd{

telegram/base.go

 
 import (
 	"context"
+	"fmt"
 	"math/rand"
 	"net"
 	"time"
 
-	"github.com/juju/errors"
-
 	"github.com/9seconds/mtg/conntypes"
 	"github.com/9seconds/mtg/utils"
 	"github.com/9seconds/mtg/wrappers"
 	addr string) (wrappers.StreamReadWriteCloser, error) {
 	conn, err := b.dialer.Dial("tcp", addr)
 	if err != nil {
-		return nil, errors.Annotate(err, "Dial has failed")
+		return nil, fmt.Errorf("dial has failed: %w", err)
 	}
 
 	if err := utils.InitTCP(conn); err != nil {
-		return nil, errors.Annotate(err, "Cannot initialize TCP socket")
+		return nil, fmt.Errorf("cannot initialize tcp socket: %w", err)
 	}
 
 	return wrappers.NewTelegramConn(ctx, cancel, conn), nil

utils/init_tcp.go

 package utils
 
 import (
+	"fmt"
 	"net"
 
-	"github.com/juju/errors"
-
 	"github.com/9seconds/mtg/config"
 )
 
 	tcpConn := conn.(*net.TCPConn)
 
 	if err := tcpConn.SetNoDelay(true); err != nil {
-		return errors.Annotate(err, "Cannot set NO_DELAY")
+		return fmt.Errorf("cannot set TCP_NO_DELAY: %w", err)
 	}
 	if err := tcpConn.SetReadBuffer(config.C.BufferSize.Read); err != nil {
-		return errors.Annotate(err, "Cannot set read buffer size")
+		return fmt.Errorf("cannot set read buffer size: %w", err)
 	}
 	if err := tcpConn.SetWriteBuffer(config.C.BufferSize.Write); err != nil {
-		return errors.Annotate(err, "Cannot set write buffer size")
+		return fmt.Errorf("cannot set write buffer size: %w", err)
 	}
 
 	return nil

utils/rlimit.go

 package utils
 
 import (
-	"golang.org/x/sys/unix"
+	"fmt"
 
-	"github.com/juju/errors"
+	"golang.org/x/sys/unix"
 )
 
-func SetLimits() (err error) {
+func SetLimits() error {
 	rLimit := unix.Rlimit{}
-	err = unix.Getrlimit(unix.RLIMIT_NOFILE, &rLimit)
-	if err != nil {
-		err = errors.Annotate(err, "Cannot get rlimit")
-		return
+	if err := unix.Getrlimit(unix.RLIMIT_NOFILE, &rLimit); err != nil {
+		return fmt.Errorf("cannot get rlimit: %w", err)
 	}
 	rLimit.Cur = rLimit.Max
 
-	err = unix.Setrlimit(unix.RLIMIT_NOFILE, &rLimit)
-	if err != nil {
-		err = errors.Annotate(err, "Cannot set rlimit")
+	if err := unix.Setrlimit(unix.RLIMIT_NOFILE, &rLimit); err != nil {
+		return fmt.Errorf("cannot set rlimit: %w", err)
 	}
 
-	return
+	return nil
 }

wrappers/wrapper_conn.go

 	"context"
 	"crypto/rand"
 	"encoding/hex"
+	"fmt"
 	"net"
 	"time"
 
-	"github.com/juju/errors"
 	"go.uber.org/zap"
 
 	"github.com/9seconds/mtg/config"
 	select {
 	case <-w.ctx.Done():
 		w.Close()
-		return 0, errors.Annotate(w.ctx.Err(), "Cannot write because context was closed")
+		return 0, fmt.Errorf("cannot write because context was closed: %w", w.ctx.Err())
 
 	default:
 		if err := w.parent.SetWriteDeadline(time.Now().Add(timeout)); err != nil {
 			w.Close() // nolint: gosec
-			return 0, errors.Annotate(err, "Cannot set write deadline to the socket")
+			return 0, fmt.Errorf("cannot set write deadline to the socket: %w", err)
 		}
 
 		n, err := w.parent.Write(p)
 	select {
 	case <-w.ctx.Done():
 		w.Close()
-		return 0, errors.Annotate(w.ctx.Err(), "Cannot read because context was closed")
+		return 0, fmt.Errorf("cannot read because context was closed: %w", w.ctx.Err())
 
 	default:
 		if err := w.parent.SetReadDeadline(time.Now().Add(timeout)); err != nil {
 			w.Close()
-			return 0, errors.Annotate(err, "Cannot set read deadline to the socket")
+			return 0, fmt.Errorf("cannot set read deadline to the socket: %w", err)
 		}
 
 		n, err := w.parent.Read(p)

wrappers/wrapper_obfuscated2.go

 
 import (
 	"crypto/cipher"
+	"fmt"
 	"net"
 	"time"
 
-	"github.com/juju/errors"
 	"go.uber.org/zap"
 )
 
 func (w *wrapperObfuscated2) ReadTimeout(p []byte, timeout time.Duration) (int, error) {
 	n, err := w.parent.ReadTimeout(p, timeout)
 	if err != nil {
-		return 0, errors.Annotate(err, "Cannot read stream ciphered data")
+		return 0, fmt.Errorf("cannot read stream ciphered data: %w", err)
 	}
 	w.decryptor.XORKeyStream(p, p[:n])
 
 func (w *wrapperObfuscated2) Read(p []byte) (int, error) {
 	n, err := w.parent.Read(p)
 	if err != nil {
-		return 0, errors.Annotate(err, "Cannot read stream ciphered data")
+		return n, err
 	}
 	w.decryptor.XORKeyStream(p, p[:n])