Remove panic() and handle it appropriately (#5807)

This is an effort to remove panic from the source. 
Add a new call called CriticialIf, that calls LogIf and exits. 
Replace panics with one of CriticalIf, FatalIf and a return of error.

pkg/auth/credentials.go

@@ -81,30 +81,37 @@ func (cred Credentials) Equal(ccred Credentials) bool {
 	return cred.AccessKey == ccred.AccessKey && subtle.ConstantTimeCompare([]byte(cred.SecretKey), []byte(ccred.SecretKey)) == 1
 }
 
-// MustGetNewCredentials generates and returns new credential.
-func MustGetNewCredentials() (cred Credentials) {
-	readBytes := func(size int) (data []byte) {
+// GetNewCredentials generates and returns new credential.
+func GetNewCredentials() (cred Credentials, err error) {
+	readBytes := func(size int) (data []byte, err error) {
 		data = make([]byte, size)
-		if n, err := rand.Read(data); err != nil {
-			panic(err)
+		var n int
+		if n, err = rand.Read(data); err != nil {
+			return nil, err
 		} else if n != size {
-			panic(fmt.Errorf("not enough data read. expected: %v, got: %v", size, n))
+			return nil, fmt.Errorf("Not enough data. Expected to read: %v bytes, got: %v bytes", size, n)
 		}
-		return
+		return data, nil
 	}
 
 	// Generate access key.
-	keyBytes := readBytes(accessKeyMaxLen)
+	keyBytes, err := readBytes(accessKeyMaxLen)
+	if err != nil {
+		return cred, err
+	}
 	for i := 0; i < accessKeyMaxLen; i++ {
 		keyBytes[i] = alphaNumericTable[keyBytes[i]%alphaNumericTableLen]
 	}
 	cred.AccessKey = string(keyBytes)
 
 	// Generate secret key.
-	keyBytes = readBytes(secretKeyMaxLen)
+	keyBytes, err = readBytes(secretKeyMaxLen)
+	if err != nil {
+		return cred, err
+	}
 	cred.SecretKey = string([]byte(base64.StdEncoding.EncodeToString(keyBytes))[:secretKeyMaxLen])
 
-	return cred
+	return cred, nil
 }
 
 // CreateCredentials returns new credential with the given access key and secret key.

pkg/auth/credentials_test.go

@@ -54,8 +54,11 @@ func TestIsSecretKeyValid(t *testing.T) {
 	}
 }
 
-func TestMustGetNewCredentials(t *testing.T) {
-	cred := MustGetNewCredentials()
+func TestGetNewCredentials(t *testing.T) {
+	cred, err := GetNewCredentials()
+	if err != nil {
+		t.Fatalf("Failed to get a new credential")
+	}
 	if !cred.IsValid() {
 		t.Fatalf("Failed to get new valid credential")
 	}
@@ -106,7 +109,14 @@ func TestCreateCredentials(t *testing.T) {
 }
 
 func TestCredentialsEqual(t *testing.T) {
-	cred := MustGetNewCredentials()
+	cred, err := GetNewCredentials()
+	if err != nil {
+		t.Fatalf("Failed to get a new credential")
+	}
+	cred2, err := GetNewCredentials()
+	if err != nil {
+		t.Fatalf("Failed to get a new credential")
+	}
 	testCases := []struct {
 		cred           Credentials
 		ccred          Credentials
@@ -119,7 +129,7 @@ func TestCredentialsEqual(t *testing.T) {
 		// Empty credentials.
 		{Credentials{}, cred, false},
 		// Two different credentialss
-		{cred, MustGetNewCredentials(), false},
+		{cred, cred2, false},
 		// Access key is different in credentials to compare.
 		{cred, Credentials{AccessKey: "myuser", SecretKey: cred.SecretKey}, false},
 		// Secret key is different in credentials to compare.

pkg/event/target/httpclient.go

@@ -19,7 +19,6 @@ package target
 import (
 	"encoding/json"
 	"errors"
-	"fmt"
 	"net/http"
 	"sync/atomic"
 	"time"
@@ -118,24 +117,28 @@ func (target *HTTPClientTarget) Close() error {
 	return nil
 }
 
-func mustGetNewUUID() string {
+func getNewUUID() (string, error) {
 	uuid, err := uuid.New()
 	if err != nil {
-		panic(fmt.Sprintf("%s. Unable to generate random UUID", err))
+		return "", err
 	}
 
-	return uuid.String()
+	return uuid.String(), nil
 }
 
 // NewHTTPClientTarget - creates new HTTP client target.
-func NewHTTPClientTarget(host xnet.Host, w http.ResponseWriter) *HTTPClientTarget {
+func NewHTTPClientTarget(host xnet.Host, w http.ResponseWriter) (*HTTPClientTarget, error) {
+	uuid, err := getNewUUID()
+	if err != nil {
+		return nil, err
+	}
 	c := &HTTPClientTarget{
-		id:      event.TargetID{"httpclient" + "+" + mustGetNewUUID() + "+" + host.Name, host.Port.String()},
+		id:      event.TargetID{"httpclient" + "+" + uuid + "+" + host.Name, host.Port.String()},
 		w:       w,
 		eventCh: make(chan []byte),
 		DoneCh:  make(chan struct{}),
 		stopCh:  make(chan struct{}),
 	}
 	c.start()
-	return c
+	return c, nil
 }

pkg/event/target/nats.go

@@ -112,7 +112,10 @@ func NewNATSTarget(id string, args NATSArgs) (*NATSTarget, error) {
 
 		clientID := args.Streaming.ClientID
 		if clientID == "" {
-			clientID = mustGetNewUUID()
+			clientID, err = getNewUUID()
+			if err != nil {
+				return nil, err
+			}
 		}
 
 		connOpts := []stan.Option{stan.NatsURL(addressURL)}

pkg/net/host.go

@@ -139,12 +139,3 @@ func ParseHost(s string) (*Host, error) {
 		IsPortSet: isPortSet,
 	}, nil
 }
-
-// MustParseHost - parses given string to Host, else panics.
-func MustParseHost(s string) *Host {
-	host, err := ParseHost(s)
-	if err != nil {
-		panic(err)
-	}
-	return host
-}

pkg/net/host_test.go

@@ -207,30 +207,3 @@ func TestParseHost(t *testing.T) {
 		}
 	}
 }
-
-func TestMustParseHost(t *testing.T) {
-	testCases := []struct {
-		s            string
-		expectedHost *Host
-	}{
-		{"play", &Host{"play", 0, false}},
-		{"play:0", &Host{"play", 0, true}},
-		{"play:9000", &Host{"play", 9000, true}},
-		{"play.minio.io", &Host{"play.minio.io", 0, false}},
-		{"play.minio.io:9000", &Host{"play.minio.io", 9000, true}},
-		{"147.75.201.93", &Host{"147.75.201.93", 0, false}},
-		{"147.75.201.93:9000", &Host{"147.75.201.93", 9000, true}},
-		{"play12", &Host{"play12", 0, false}},
-		{"12play", &Host{"12play", 0, false}},
-		{"play-minio-io", &Host{"play-minio-io", 0, false}},
-		{"play--minio.io", &Host{"play--minio.io", 0, false}},
-	}
-
-	for i, testCase := range testCases {
-		host := MustParseHost(testCase.s)
-
-		if !reflect.DeepEqual(host, testCase.expectedHost) {
-			t.Fatalf("test %v: host: expected: %#v, got: %#v", i+1, testCase.expectedHost, host)
-		}
-	}
-}

pkg/net/port.go

@@ -42,13 +42,3 @@ func ParsePort(s string) (p Port, err error) {
 
 	return Port(i), nil
 }
-
-// MustParsePort - parses string into Port, else panics
-func MustParsePort(s string) Port {
-	p, err := ParsePort(s)
-	if err != nil {
-		panic(err)
-	}
-
-	return p
-}

pkg/net/port_test.go

@@ -71,22 +71,3 @@ func TestParsePort(t *testing.T) {
 		}
 	}
 }
-
-func TestMustParsePort(t *testing.T) {
-	testCases := []struct {
-		s            string
-		expectedPort Port
-	}{
-		{"0", Port(0)},
-		{"9000", Port(9000)},
-		{"65535", Port(65535)},
-	}
-
-	for i, testCase := range testCases {
-		port := MustParsePort(testCase.s)
-
-		if port != testCase.expectedPort {
-			t.Fatalf("test %v: error: port: %v, got: %v", i+1, testCase.expectedPort, port)
-		}
-	}
-}

pkg/net/url.go

@@ -35,7 +35,10 @@ func (u URL) IsEmpty() bool {
 func (u URL) String() string {
 	// if port number 80 and 443, remove for http and https scheme respectively
 	if u.Host != "" {
-		host := MustParseHost(u.Host)
+		host, err := ParseHost(u.Host)
+		if err != nil {
+			panic(err)
+		}
 		switch {
 		case u.Scheme == "http" && host.Port == 80:
 			fallthrough