Evacuate some frames to a separate package

We need that to be able to implement code that target these frames on a
separate package.

Author: dkropachev

cassandra_test.go

@@ -43,6 +43,7 @@ import (
 	"time"
 	"unicode"
 
+	frm "github.com/gocql/gocql/internal/frame"
 	"github.com/gocql/gocql/internal/tests"
 
 	"github.com/stretchr/testify/require"
@@ -2484,7 +2485,7 @@ func TestNegativeStream(t *testing.T) {
 
 	const stream = -50
 	writer := frameWriterFunc(func(f *framer, streamID int) error {
-		f.writeHeader(0, opOptions, stream)
+		f.writeHeader(0, frm.OpOptions, stream)
 		return f.finish()
 	})
 

conn.go

@@ -39,6 +39,7 @@ import (
 	"sync/atomic"
 	"time"
 
+	frm "github.com/gocql/gocql/internal/frame"
 	"github.com/gocql/gocql/tablets"
 
 	"github.com/gocql/gocql/internal/lru"
@@ -509,12 +510,12 @@ func (s *startupCoordinator) options(ctx context.Context) error {
 		return err
 	}
 
-	v, ok := frame.(*supportedFrame)
+	v, ok := frame.(*frm.SupportedFrame)
 	if !ok {
 		return NewErrProtocol("Unknown type of response to startup frame: %T", frame)
 	}
 	// Keep raw supported multimap for debug purposes
-	s.conn.supported = v.supported
+	s.conn.supported = v.Supported
 	s.conn.scyllaSupported = parseSupported(s.conn.supported, s.conn.logger)
 	s.conn.recalculateSystemRequestTimeout()
 	s.conn.host.setScyllaSupported(s.conn.scyllaSupported)
@@ -564,21 +565,21 @@ func (s *startupCoordinator) startup(ctx context.Context) error {
 	switch v := frame.(type) {
 	case error:
 		return v
-	case *readyFrame:
+	case *frm.ReadyFrame:
 		return nil
-	case *authenticateFrame:
+	case *frm.AuthenticateFrame:
 		return s.authenticateHandshake(ctx, v)
 	default:
 		return NewErrProtocol("Unknown type of response to startup frame: %s", v)
 	}
 }
 
-func (s *startupCoordinator) authenticateHandshake(ctx context.Context, authFrame *authenticateFrame) error {
+func (s *startupCoordinator) authenticateHandshake(ctx context.Context, authFrame *frm.AuthenticateFrame) error {
 	if s.conn.auth == nil {
-		return fmt.Errorf("authentication required (using %q)", authFrame.class)
+		return fmt.Errorf("authentication required (using %q)", authFrame.Class)
 	}
 
-	resp, challenger, err := s.conn.auth.Challenge([]byte(authFrame.class))
+	resp, challenger, err := s.conn.auth.Challenge([]byte(authFrame.Class))
 	if err != nil {
 		return err
 	}
@@ -593,13 +594,13 @@ func (s *startupCoordinator) authenticateHandshake(ctx context.Context, authFram
 		switch v := frame.(type) {
 		case error:
 			return v
-		case *authSuccessFrame:
+		case *frm.AuthSuccessFrame:
 			if challenger != nil {
-				return challenger.Success(v.data)
+				return challenger.Success(v.Data)
 			}
 			return nil
-		case *authChallengeFrame:
-			resp, challenger, err = challenger.Challenge(v.data)
+		case *frm.AuthChallengeFrame:
+			resp, challenger, err = challenger.Challenge(v.Data)
 			if err != nil {
 				return err
 			}
@@ -696,8 +697,8 @@ func (c *Conn) serve(ctx context.Context) {
 	c.closeWithError(err)
 }
 
-func (c *Conn) discardFrame(head frameHeader) error {
-	_, err := io.CopyN(ioutil.Discard, c, int64(head.length))
+func (c *Conn) discardFrame(head frm.FrameHeader) error {
+	_, err := io.CopyN(ioutil.Discard, c, int64(head.Length))
 	if err != nil {
 		return err
 	}
@@ -712,7 +713,7 @@ func (p *protocolError) Error() string {
 	if err, ok := p.frame.(error); ok {
 		return err.Error()
 	}
-	return fmt.Sprintf("gocql: received unexpected frame on stream %d: %v", p.frame.Header().stream, p.frame)
+	return fmt.Sprintf("gocql: received unexpected frame on stream %d: %v", p.frame.Header().Stream, p.frame)
 }
 
 func (c *Conn) heartBeat(ctx context.Context) {
@@ -750,7 +751,7 @@ func (c *Conn) heartBeat(ctx context.Context) {
 		}
 
 		switch resp.(type) {
-		case *supportedFrame:
+		case *frm.SupportedFrame:
 			// Everything ok
 			sleepTime = 30 * time.Second
 			failures = 0
@@ -781,20 +782,20 @@ func (c *Conn) recv(ctx context.Context) error {
 
 	if c.frameObserver != nil {
 		c.frameObserver.ObserveFrameHeader(context.Background(), ObservedFrameHeader{
-			Version: protoVersion(head.version),
-			Flags:   head.flags,
-			Stream:  int16(head.stream),
-			Opcode:  frameOp(head.op),
-			Length:  int32(head.length),
+			Version: head.Version,
+			Flags:   head.Flags,
+			Stream:  int16(head.Stream),
+			Opcode:  head.Op,
+			Length:  int32(head.Length),
 			Start:   headStartTime,
 			End:     headEndTime,
 			Host:    c.host,
 		})
 	}
 
-	if head.stream > c.streams.NumStreams {
-		return fmt.Errorf("gocql: frame header stream is beyond call expected bounds: %d", head.stream)
-	} else if head.stream == -1 {
+	if head.Stream > c.streams.NumStreams {
+		return fmt.Errorf("gocql: frame header stream is beyond call expected bounds: %d", head.Stream)
+	} else if head.Stream == -1 {
 		// TODO: handle cassandra event frames, we shouldnt get any currently
 		framer := newFramerWithExts(c.compressor, c.version, c.cqlProtoExts, c.logger)
 		c.setTabletSupported(framer.tabletsRoutingV1)
@@ -803,7 +804,7 @@ func (c *Conn) recv(ctx context.Context) error {
 		}
 		go c.session.handleEvent(framer)
 		return nil
-	} else if head.stream <= 0 {
+	} else if head.Stream <= 0 {
 		// reserved stream that we dont use, probably due to a protocol error
 		// or a bug in Cassandra, this should be an error, parse it and return.
 		framer := newFramerWithExts(c.compressor, c.version, c.cqlProtoExts, c.logger)
@@ -827,14 +828,14 @@ func (c *Conn) recv(ctx context.Context) error {
 		c.mu.Unlock()
 		return ErrConnectionClosed
 	}
-	call, ok := c.calls[head.stream]
-	delete(c.calls, head.stream)
+	call, ok := c.calls[head.Stream]
+	delete(c.calls, head.Stream)
 	c.mu.Unlock()
 	if call == nil || !ok {
 		c.logger.Printf("gocql: received response for stream which has no handler: header=%v\n", head)
 		return c.discardFrame(head)
-	} else if head.stream != call.streamID {
-		panic(fmt.Sprintf("call has incorrect streamID: got %d expected %d", call.streamID, head.stream))
+	} else if head.Stream != call.streamID {
+		panic(fmt.Sprintf("call has incorrect streamID: got %d expected %d", call.streamID, head.Stream))
 	}
 
 	framer := newFramerWithExts(c.compressor, c.version, c.cqlProtoExts, c.logger)
@@ -1262,7 +1263,7 @@ func (c *Conn) exec(ctx context.Context, req frameBuilder, tracer Tracer, reques
 		// requests on the stream to prevent nil pointer dereferences in recv().
 		defer c.releaseStream(call)
 
-		if v := resp.framer.header.version.version(); v != c.version {
+		if v := resp.framer.header.Version.Version(); v != c.version {
 			return nil, &QueryError{err: NewErrProtocol("unexpected protocol version in response: got %d expected %d", v, c.version), potentiallyExecuted: true}
 		}
 
@@ -1610,7 +1611,7 @@ func (c *Conn) executeQuery(ctx context.Context, qry *Query) (iter *Iter) {
 		return iter
 	case *resultKeyspaceFrame:
 		return &Iter{framer: framer}
-	case *schemaChangeKeyspace, *schemaChangeTable, *schemaChangeFunction, *schemaChangeAggregate, *schemaChangeType:
+	case *frm.SchemaChangeKeyspace, *frm.SchemaChangeTable, *frm.SchemaChangeFunction, *frm.SchemaChangeAggregate, *frm.SchemaChangeType:
 		iter := &Iter{framer: framer}
 		if err := c.awaitSchemaAgreement(ctx); err != nil {
 			// TODO: should have this behind a flag