error messages were refactored

Author: tengu-alt

cluster.go

@@ -309,7 +309,7 @@ func (cfg *ClusterConfig) filterHost(host *HostInfo) bool {
 }
 
 var (
-	ErrNoHosts              = errors.New("no hosts provided")
-	ErrNoConnectionsStarted = errors.New("no connections were made when creating the session")
-	ErrHostQueryFailed      = errors.New("unable to populate Hosts")
+	ErrAuthenticatorAndAuthProvider = errors.New("gocql: Can't use both Authenticator and AuthProvider in cluster config.")
+	ErrNoHosts                      = errors.New("gocql: no hosts provided")
+	ErrNoConnectionsStarted         = errors.New("gocql: no connections were made when creating the session")
 )

conn.go

@@ -74,7 +74,7 @@ type PasswordAuthenticator struct {
 
 func (p PasswordAuthenticator) Challenge(req []byte) ([]byte, Authenticator, error) {
 	if !approve(string(req), p.AllowedAuthenticators) {
-		return nil, nil, fmt.Errorf("unexpected authenticator %q", req)
+		return nil, nil, fmt.Errorf("gocql: unexpected authenticator %q", req)
 	}
 	resp := make([]byte, 2+len(p.Username)+len(p.Password))
 	resp[0] = 0
@@ -464,7 +464,7 @@ func (s *startupCoordinator) startup(ctx context.Context, supported map[string][
 
 func (s *startupCoordinator) authenticateHandshake(ctx context.Context, authFrame *authenticateFrame) error {
 	if s.conn.auth == nil {
-		return fmt.Errorf("authentication required (using %q)", authFrame.class)
+		return fmt.Errorf("gocql: authentication required (using %q)", authFrame.class)
 	}
 
 	resp, challenger, err := s.conn.auth.Challenge([]byte(authFrame.class))
@@ -497,7 +497,7 @@ func (s *startupCoordinator) authenticateHandshake(ctx context.Context, authFram
 				data: resp,
 			}
 		default:
-			return fmt.Errorf("unknown frame response during authentication: %v", v)
+			return fmt.Errorf("gocql: unknown frame response during authentication: %v", v)
 		}
 	}
 }
@@ -999,7 +999,7 @@ func (c *Conn) addCall(call *callReq) error {
 	}
 	existingCall := c.calls[call.streamID]
 	if existingCall != nil {
-		return fmt.Errorf("attempting to use stream already in use: %d -> %d", call.streamID,
+		return fmt.Errorf("gocql: attempting to use stream already in use: %d -> %d", call.streamID,
 			existingCall.streamID)
 	}
 	c.calls[call.streamID] = call
@@ -1271,7 +1271,7 @@ func (c *Conn) prepareStatement(ctx context.Context, stmt string, tracer Tracer)
 					response: x.respMeta,
 				}
 			case error:
-				flight.err = x
+				flight.err = fmt.Errorf("cassandra: %w", x)
 			default:
 				flight.err = NewErrProtocol("Unknown type in response to prepare frame: %s", x)
 			}
@@ -1508,7 +1508,7 @@ func (c *Conn) UseKeyspace(keyspace string) error {
 	switch x := resp.(type) {
 	case *resultKeyspaceFrame:
 	case error:
-		return x
+		return fmt.Errorf("cassandra: %w", x)
 	default:
 		return NewErrProtocol("unknown frame in response to USE: %v", x)
 	}
@@ -1616,7 +1616,7 @@ func (c *Conn) executeBatch(ctx context.Context, batch *Batch) *Iter {
 
 		return iter
 	case error:
-		return &Iter{err: x, framer: framer}
+		return &Iter{err: fmt.Errorf("cassandra: %w", x), framer: framer}
 	default:
 		return &Iter{err: NewErrProtocol("Unknown type in response to batch statement: %s", x), framer: framer}
 	}

control.go

@@ -131,7 +131,7 @@ func hostInfo(addr string, defaultPort int) ([]*HostInfo, error) {
 	if err != nil {
 		return nil, err
 	} else if len(ips) == 0 {
-		return nil, fmt.Errorf("no IP's returned from DNS lookup for %q", addr)
+		return nil, fmt.Errorf("gocql: no IP's returned from DNS lookup for %q", addr)
 	}
 
 	// Filter to v4 addresses if any present
@@ -251,7 +251,7 @@ func (c *controlConn) connect(hosts []*HostInfo) error {
 		conn = nil
 	}
 	if conn == nil {
-		return fmt.Errorf("unable to connect to initial hosts: %v", err)
+		return fmt.Errorf("gocql: unable to connect to initial hosts: %w", err)
 	}
 
 	// we could fetch the initial ring here and update initial host data. So that
@@ -278,11 +278,11 @@ func (c *controlConn) setupConn(conn *Conn) error {
 	host = c.session.ring.addOrUpdate(host)
 
 	if c.session.cfg.filterHost(host) {
-		return fmt.Errorf("host was filtered: %v", host.ConnectAddress())
+		return fmt.Errorf("gocql: host was filtered: %v", host.ConnectAddress())
 	}
 
 	if err := c.registerEvents(conn); err != nil {
-		return fmt.Errorf("register events: %v", err)
+		return fmt.Errorf("gocql: register events: %w", err)
 	}
 
 	ch := &connHost{
@@ -332,7 +332,7 @@ func (c *controlConn) registerEvents(conn *Conn) error {
 	if err != nil {
 		return err
 	} else if _, ok := frame.(*readyFrame); !ok {
-		return fmt.Errorf("unexpected frame in response to register: got %T: %v\n", frame, frame)
+		return fmt.Errorf("gocql: unexpected frame in response to register: got %T: %v\n", frame, frame)
 	}
 
 	return nil
@@ -389,7 +389,7 @@ func (c *controlConn) attemptReconnect() (*Conn, error) {
 	// changed their IPs while keeping the same hostname(s).
 	initialHosts, resolvErr := addrsToHosts(c.session.cfg.Hosts, c.session.cfg.Port, c.session.logger)
 	if resolvErr != nil {
-		return nil, fmt.Errorf("resolve contact points' hostnames: %v", resolvErr)
+		return nil, fmt.Errorf("gocql: resolve contact points' hostnames: %w", resolvErr)
 	}
 
 	return c.attemptReconnectToAnyOfHosts(initialHosts)

dial.go

@@ -40,9 +40,9 @@ func (hd *defaultHostDialer) DialHost(ctx context.Context, host *HostInfo) (*Dia
 	port := host.Port()
 
 	if !validIpAddr(ip) {
-		return nil, fmt.Errorf("host missing connect ip address: %v", ip)
+		return nil, fmt.Errorf("gocql: host missing connect ip address: %v", ip)
 	} else if port == 0 {
-		return nil, fmt.Errorf("host missing port: %v", port)
+		return nil, fmt.Errorf("gocql: host missing port: %v", port)
 	}
 
 	connAddr := host.ConnectAddressAndPort()

filters.go

@@ -43,7 +43,7 @@ func WhiteListHostFilter(hosts ...string) HostFilter {
 	hostInfos, err := addrsToHosts(hosts, 9042, nopLogger{})
 	if err != nil {
 		// dont want to panic here, but rather not break the API
-		panic(fmt.Errorf("unable to lookup host info from address: %v", err))
+		panic(fmt.Errorf("gocql: unable to lookup host info from address: %w", err))
 	}
 
 	m := make(map[string]bool, len(hostInfos))

frame.go

@@ -234,7 +234,7 @@ func (c *Consistency) UnmarshalText(text []byte) error {
 	case "LOCAL_ONE":
 		*c = LocalOne
 	default:
-		return fmt.Errorf("invalid consistency %q", string(text))
+		return fmt.Errorf("gocql: invalid consistency %q", string(text))
 	}
 
 	return nil
@@ -295,7 +295,7 @@ func (s *SerialConsistency) UnmarshalText(text []byte) error {
 	case "LOCAL_SERIAL":
 		*s = LocalSerial
 	default:
-		return fmt.Errorf("invalid consistency %q", string(text))
+		return fmt.Errorf("gocql: invalid consistency %q", string(text))
 	}
 
 	return nil
@@ -306,7 +306,7 @@ const (
 )
 
 var (
-	ErrFrameTooBig = errors.New("frame length is bigger than the maximum allowed")
+	ErrFrameTooBig = errors.New("gocql: frame length is bigger than the maximum allowed")
 )
 
 const maxFrameHeaderSize = 9
@@ -449,15 +449,15 @@ func readHeader(r io.Reader, p []byte) (head frameHeader, err error) {
 
 	if version > protoVersion2 {
 		if len(p) != 9 {
-			return frameHeader{}, fmt.Errorf("not enough bytes to read header require 9 got: %d", len(p))
+			return frameHeader{}, fmt.Errorf("gocql: not enough bytes to read header require 9 got: %d", len(p))
 		}
 
 		head.stream = int(int16(p[2])<<8 | int16(p[3]))
 		head.op = frameOp(p[4])
 		head.length = int(readInt(p[5:]))
 	} else {
 		if len(p) != 8 {
-			return frameHeader{}, fmt.Errorf("not enough bytes to read header require 8 got: %d", len(p))
+			return frameHeader{}, fmt.Errorf("gocql: not enough bytes to read header require 8 got: %d", len(p))
 		}
 
 		head.stream = int(int8(p[2]))
@@ -481,12 +481,12 @@ func (f *framer) payload() {
 // reads a frame form the wire into the framers buffer
 func (f *framer) readFrame(r io.Reader, head *frameHeader) error {
 	if head.length < 0 {
-		return fmt.Errorf("frame body length can not be less than 0: %d", head.length)
+		return fmt.Errorf("gocql: frame body length can not be less than 0: %d", head.length)
 	} else if head.length > maxFrameSize {
 		// need to free up the connection to be used again
 		_, err := io.CopyN(ioutil.Discard, r, int64(head.length))
 		if err != nil {
-			return fmt.Errorf("error whilst trying to discard frame with invalid length: %v", err)
+			return fmt.Errorf("gocql: error whilst trying to discard frame with invalid length: %w", err)
 		}
 		return ErrFrameTooBig
 	}
@@ -501,7 +501,7 @@ func (f *framer) readFrame(r io.Reader, head *frameHeader) error {
 	// assume the underlying reader takes care of timeouts and retries
 	n, err := io.ReadFull(r, f.buf)
 	if err != nil {
-		return fmt.Errorf("unable to read frame body: read %d/%d bytes: %v", n, head.length, err)
+		return fmt.Errorf("gocql: unable to read frame body: read %d/%d bytes: %w", n, head.length, err)
 	}
 
 	if head.flags&flagCompress == flagCompress {
@@ -511,7 +511,7 @@ func (f *framer) readFrame(r io.Reader, head *frameHeader) error {
 
 		f.buf, err = f.compres.Decode(f.buf)
 		if err != nil {
-			return err
+			return fmt.Errorf("gocql: %w", err)
 		}
 	}
 
@@ -687,7 +687,7 @@ func (f *framer) parseErrorFrame() frame {
 		// TODO(zariel): we should have some distinct types for these errors
 		return errD
 	default:
-		panic(fmt.Errorf("unknown error code: 0x%x", errD.code))
+		panic(fmt.Errorf("gocql: unknown error code: 0x%x", errD.code))
 	}
 }
 
@@ -756,7 +756,7 @@ func (f *framer) finish() error {
 		// TODO: only compress frames which are big enough
 		compressed, err := f.compres.Encode(f.buf[f.headSize:])
 		if err != nil {
-			return err
+			return fmt.Errorf("gocql: %w", err)
 		}
 
 		f.buf = append(f.buf[:f.headSize], compressed...)
@@ -836,7 +836,7 @@ func (w *writePrepareFrame) buildFrame(f *framer, streamID int) error {
 		if f.proto > protoVersion4 {
 			flags |= flagWithPreparedKeyspace
 		} else {
-			panic(fmt.Errorf("the keyspace can only be set with protocol 5 or higher"))
+			panic(fmt.Errorf("gocql: the keyspace can only be set with protocol 5 or higher"))
 		}
 	}
 	if f.proto > protoVersion4 {
@@ -935,7 +935,7 @@ func (f *framer) parsePreparedMetadata() preparedMetadata {
 	meta.flags = f.readInt()
 	meta.colCount = f.readInt()
 	if meta.colCount < 0 {
-		panic(fmt.Errorf("received negative column count: %d", meta.colCount))
+		panic(fmt.Errorf("gocql: received negative column count: %d", meta.colCount))
 	}
 	meta.actualColCount = meta.colCount
 
@@ -1032,7 +1032,7 @@ func (f *framer) parseResultMetadata() resultMetadata {
 	meta.flags = f.readInt()
 	meta.colCount = f.readInt()
 	if meta.colCount < 0 {
-		panic(fmt.Errorf("received negative column count: %d", meta.colCount))
+		panic(fmt.Errorf("gocql: received negative column count: %d", meta.colCount))
 	}
 	meta.actualColCount = meta.colCount
 
@@ -1119,7 +1119,7 @@ func (f *framer) parseResultRows() frame {
 
 	result.numRows = f.readInt()
 	if result.numRows < 0 {
-		panic(fmt.Errorf("invalid row_count in result frame: %d", result.numRows))
+		panic(fmt.Errorf("gocql: invalid row_count in result frame: %d", result.numRows))
 	}
 
 	return result
@@ -1487,7 +1487,7 @@ func (f *framer) writeQueryParams(opts *queryParams) {
 		if f.proto > protoVersion4 {
 			flags |= flagWithKeyspace
 		} else {
-			panic(fmt.Errorf("the keyspace can only be set with protocol 5 or higher"))
+			panic(fmt.Errorf("gocql: the keyspace can only be set with protocol 5 or higher"))
 		}
 	}
 
@@ -1750,7 +1750,7 @@ func (f *framer) writeRegisterFrame(streamID int, w *writeRegisterFrame) error {
 
 func (f *framer) readByte() byte {
 	if len(f.buf) < 1 {
-		panic(fmt.Errorf("not enough bytes in buffer to read byte require 1 got: %d", len(f.buf)))
+		panic(fmt.Errorf("gocql: not enough bytes in buffer to read byte require 1 got: %d", len(f.buf)))
 	}
 
 	b := f.buf[0]
@@ -1760,7 +1760,7 @@ func (f *framer) readByte() byte {
 
 func (f *framer) readInt() (n int) {
 	if len(f.buf) < 4 {
-		panic(fmt.Errorf("not enough bytes in buffer to read int require 4 got: %d", len(f.buf)))
+		panic(fmt.Errorf("gocql: not enough bytes in buffer to read int require 4 got: %d", len(f.buf)))
 	}
 
 	n = int(int32(f.buf[0])<<24 | int32(f.buf[1])<<16 | int32(f.buf[2])<<8 | int32(f.buf[3]))
@@ -1770,7 +1770,7 @@ func (f *framer) readInt() (n int) {
 
 func (f *framer) readShort() (n uint16) {
 	if len(f.buf) < 2 {
-		panic(fmt.Errorf("not enough bytes in buffer to read short require 2 got: %d", len(f.buf)))
+		panic(fmt.Errorf("gocql: not enough bytes in buffer to read short require 2 got: %d", len(f.buf)))
 	}
 	n = uint16(f.buf[0])<<8 | uint16(f.buf[1])
 	f.buf = f.buf[2:]
@@ -1781,7 +1781,7 @@ func (f *framer) readString() (s string) {
 	size := f.readShort()
 
 	if len(f.buf) < int(size) {
-		panic(fmt.Errorf("not enough bytes in buffer to read string require %d got: %d", size, len(f.buf)))
+		panic(fmt.Errorf("gocql: not enough bytes in buffer to read string require %d got: %d", size, len(f.buf)))
 	}
 
 	s = string(f.buf[:size])
@@ -1793,7 +1793,7 @@ func (f *framer) readLongString() (s string) {
 	size := f.readInt()
 
 	if len(f.buf) < size {
-		panic(fmt.Errorf("not enough bytes in buffer to read long string require %d got: %d", size, len(f.buf)))
+		panic(fmt.Errorf("gocql: not enough bytes in buffer to read long string require %d got: %d", size, len(f.buf)))
 	}
 
 	s = string(f.buf[:size])
@@ -1803,7 +1803,7 @@ func (f *framer) readLongString() (s string) {
 
 func (f *framer) readUUID() *UUID {
 	if len(f.buf) < 16 {
-		panic(fmt.Errorf("not enough bytes in buffer to read uuid require %d got: %d", 16, len(f.buf)))
+		panic(fmt.Errorf("gocql: not enough bytes in buffer to read uuid require %d got: %d", 16, len(f.buf)))
 	}
 
 	// TODO: how to handle this error, if it is a uuid, then sureley, problems?
@@ -1830,7 +1830,7 @@ func (f *framer) readBytesInternal() ([]byte, error) {
 	}
 
 	if len(f.buf) < size {
-		return nil, fmt.Errorf("not enough bytes in buffer to read bytes require %d got: %d", size, len(f.buf))
+		return nil, fmt.Errorf("gocql: not enough bytes in buffer to read bytes require %d got: %d", size, len(f.buf))
 	}
 
 	l := f.buf[:size]
@@ -1851,7 +1851,7 @@ func (f *framer) readBytes() []byte {
 func (f *framer) readShortBytes() []byte {
 	size := f.readShort()
 	if len(f.buf) < int(size) {
-		panic(fmt.Errorf("not enough bytes in buffer to read short bytes: require %d got %d", size, len(f.buf)))
+		panic(fmt.Errorf("gocql: not enough bytes in buffer to read short bytes: require %d got %d", size, len(f.buf)))
 	}
 
 	l := f.buf[:size]
@@ -1862,18 +1862,18 @@ func (f *framer) readShortBytes() []byte {
 
 func (f *framer) readInetAdressOnly() net.IP {
 	if len(f.buf) < 1 {
-		panic(fmt.Errorf("not enough bytes in buffer to read inet size require %d got: %d", 1, len(f.buf)))
+		panic(fmt.Errorf("gocql: not enough bytes in buffer to read inet size require %d got: %d", 1, len(f.buf)))
 	}
 
 	size := f.buf[0]
 	f.buf = f.buf[1:]
 
 	if !(size == 4 || size == 16) {
-		panic(fmt.Errorf("invalid IP size: %d", size))
+		panic(fmt.Errorf("gocql: invalid IP size: %d", size))
 	}
 
 	if len(f.buf) < 1 {
-		panic(fmt.Errorf("not enough bytes in buffer to read inet require %d got: %d", size, len(f.buf)))
+		panic(fmt.Errorf("gocql: not enough bytes in buffer to read inet require %d got: %d", size, len(f.buf)))
 	}
 
 	ip := make([]byte, size)

helpers.go

@@ -77,7 +77,7 @@ func goType(t TypeInfo) (reflect.Type, error) {
 	case TypeDuration:
 		return reflect.TypeOf(*new(Duration)), nil
 	default:
-		return nil, fmt.Errorf("cannot create Go type for unknown CQL type %s", t)
+		return nil, fmt.Errorf("gocql: cannot create Go type for unknown CQL type %s", t)
 	}
 }