github.com/datastax/go-cassandra-native-protocol@v0.0.0-20220706104457-5e8aad05cf90/message/startup.go

// Copyright 2020 DataStax
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package message

import (
	"errors"
	"fmt"
	"io"

	"github.com/datastax/go-cassandra-native-protocol/primitive"
)

const (

	// StartupOptionCqlVersion is the version of CQL to use. This option is mandatory and currently the only version
	// supported is "3.0.0". Note that this is different from the protocol version.
	StartupOptionCqlVersion = "CQL_VERSION"

	// StartupOptionCompression is the compression algorithm to use.
	StartupOptionCompression = "COMPRESSION"

	StartupOptionClientId           = "CLIENT_ID"
	StartupOptionApplicationName    = "APPLICATION_NAME"
	StartupOptionApplicationVersion = "APPLICATION_VERSION"

	// StartupOptionDriverName allows clients to supply a free-form label representing the driver implementation.
	// This is displayed in the output of `nodetool clientstats`.
	StartupOptionDriverName = "DRIVER_NAME"

	// StartupOptionDriverVersion allows clients to supply a free-form label representing the driver version. This is
	// displayed in the output of `nodetool clientstats`.
	StartupOptionDriverVersion = "DRIVER_VERSION"

	// StartupOptionThrowOnOverload specifies server behaviour where the incoming message rate is too high.
	// A [string] value of "1" instructs the server to respond with an Error when its resources are exhausted.
	// Any other value, or if the key is not present, and the server will apply backpressure to the connection until it
	// has cleared its backlog of inbound messages.
	StartupOptionThrowOnOverload = "THROW_ON_OVERLOAD"
)

// Startup is the first request message that a client sends when establishing a connection. The server will respond by
// either a Ready response message (in which case the connection is ready for queries) or with an Authenticate response
// message (in which case credentials will need to be provided using a subsequent AuthResponse request message).
// +k8s:deepcopy-gen=true
// +k8s:deepcopy-gen:interfaces=github.com/datastax/go-cassandra-native-protocol/message.Message
type Startup struct {
	// Currently supported options are:
	// - "CQL_VERSION"
	// - "COMPRESSION"
	// Starting with DSE v2 the following options are also recognized:
	// - "CLIENT_ID": string representation of the client instance. Recommended is a ID unique per runtime instance
	//   (e.g. DataStax Java Driver's CqlSession instance), generated by the driver.
	// - "APPLICATION_NAME": optional, name of the application, should include the vendor name.
	//   For example "DataStax Studio".
	// - "APPLICATION_VERSION": optional, version of the application.
	// - "DRIVER_NAME": product name of the driver implementation. For example: 'DataStax Java Driver'.
	// - "DRIVER_VERSION": version of the driver implementation, typically a semantic version string.
	Options map[string]string
}

func NewStartup(keysAndValues ...string) *Startup {
	startup := &Startup{map[string]string{StartupOptionCqlVersion: "3.0.0"}}
	for i := 0; i < len(keysAndValues); i += 2 {
		startup.Options[keysAndValues[i]] = keysAndValues[i+1]
	}
	return startup
}

func (m *Startup) GetCompression() primitive.Compression {
	if compressionStr, found := m.Options[StartupOptionCompression]; !found {
		return primitive.CompressionNone
	} else {
		return primitive.Compression(compressionStr)
	}
}

func (m *Startup) SetCompression(compression primitive.Compression) {
	if compression == primitive.CompressionNone {
		delete(m.Options, StartupOptionCompression)
	} else {
		m.Options[StartupOptionCompression] = string(compression)
	}
}

func (m *Startup) GetClientId() string {
	return m.Options[StartupOptionClientId]
}

func (m *Startup) SetClientId(clientId string) {
	m.Options[StartupOptionClientId] = clientId
}

func (m *Startup) GetApplicationName() string {
	return m.Options[StartupOptionApplicationName]
}

func (m *Startup) SetApplicationName(applicationName string) {
	m.Options[StartupOptionApplicationName] = applicationName
}

func (m *Startup) GetApplicationVersion() string {
	return m.Options[StartupOptionApplicationVersion]
}

func (m *Startup) SetApplicationVersion(applicationVersion string) {
	m.Options[StartupOptionApplicationVersion] = applicationVersion
}

func (m *Startup) GetDriverName() string {
	return m.Options[StartupOptionDriverName]
}

func (m *Startup) SetDriverName(driverName string) {
	m.Options[StartupOptionDriverName] = driverName
}

func (m *Startup) GetDriverVersion() string {
	return m.Options[StartupOptionDriverVersion]
}

func (m *Startup) SetDriverVersion(driverVersion string) {
	m.Options[StartupOptionDriverVersion] = driverVersion
}

func (m *Startup) IsThrowOnOverload() bool {
	v, found := m.Options[StartupOptionThrowOnOverload]
	return found && v == "1"
}

func (m *Startup) SetThrowOnOverload(throwOnOverload bool) {
	if throwOnOverload {
		m.Options[StartupOptionDriverVersion] = "1"
	} else {
		delete(m.Options, StartupOptionDriverVersion)
	}
}

func (m *Startup) IsResponse() bool {
	return false
}

func (m *Startup) GetOpCode() primitive.OpCode {
	return primitive.OpCodeStartup
}

func (m *Startup) String() string {
	return fmt.Sprint("STARTUP ", m.Options)
}

type startupCodec struct{}

func (c *startupCodec) Encode(msg Message, dest io.Writer, _ primitive.ProtocolVersion) error {
	startup, ok := msg.(*Startup)
	if !ok {
		return errors.New(fmt.Sprintf("expected *message.Startup, got %T", msg))
	}
	return primitive.WriteStringMap(startup.Options, dest)
}

func (c *startupCodec) EncodedLength(msg Message, _ primitive.ProtocolVersion) (int, error) {
	startup, ok := msg.(*Startup)
	if !ok {
		return -1, errors.New(fmt.Sprintf("expected *message.Startup, got %T", msg))
	}
	return primitive.LengthOfStringMap(startup.Options), nil
}

func (c *startupCodec) Decode(source io.Reader, _ primitive.ProtocolVersion) (Message, error) {
	if options, err := primitive.ReadStringMap(source); err != nil {
		return nil, err
	} else {
		return &Startup{Options: options}, nil
	}
}

func (c *startupCodec) GetOpCode() primitive.OpCode {
	return primitive.OpCodeStartup
}