coordinator

package
v0.8.0-rc.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 16, 2014 License: MIT Imports: 29 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// this is the key used for the persistent atomic ints for sequence numbers
	POINT_SEQUENCE_NUMBER_KEY = "p"

	// actual point sequence numbers will have the first part of the number
	// be a host id. This ensures that sequence numbers are unique across the cluster
	HOST_ID_OFFSET = uint64(10000)

	SHARDS_TO_QUERY_FOR_LIST_SERIES = 10
)
View Source 
const (
	REQUEST_RETRY_ATTEMPTS = 2
	MAX_RESPONSE_SIZE      = MAX_REQUEST_SIZE
	MAX_REQUEST_TIME       = time.Second * 1200
	RECONNECT_RETRY_WAIT   = time.Millisecond * 100
)
View Source 
const (
	DEFAULT_ROOT_PWD        = "root"
	DEFAULT_ROOT_PWD_ENVKEY = "INFLUXDB_INIT_PWD"
	RAFT_NAME_SIZE          = 8
)
View Source 
const KILOBYTE = 1024
View Source 
const MAX_REQUEST_SIZE = MEGABYTE * 2
View Source 
const (
	MAX_SIZE = 10 * MEGABYTE
)
View Source 
const MEGABYTE = 1024 * KILOBYTE

Variables

View Source 
var (
	BARRIER_TIME_MIN int64 = math.MinInt64
	BARRIER_TIME_MAX int64 = math.MaxInt64
)

Functions

func SendCommandToServer 

func SendCommandToServer(url string, command raft.Command) (interface{}, error)

Types

type ChangeDbUserPassword 

type ChangeDbUserPassword struct {
	Database string
	Username string
	Hash     string
}

func NewChangeDbUserPasswordCommand 

func NewChangeDbUserPasswordCommand(db, username, hash string) *ChangeDbUserPassword

func (*ChangeDbUserPassword) Apply 

func (c *ChangeDbUserPassword) Apply(server raft.Server) (interface{}, error)

func (*ChangeDbUserPassword) CommandName 

func (c *ChangeDbUserPassword) CommandName() string

type ChangeDbUserPermissions 

type ChangeDbUserPermissions struct {
	Database         string
	Username         string
	ReadPermissions  string
	WritePermissions string
}

func NewChangeDbUserPermissionsCommand 

func NewChangeDbUserPermissionsCommand(db, username, readPermissions, writePermissions string) *ChangeDbUserPermissions

func (*ChangeDbUserPermissions) Apply 

func (c *ChangeDbUserPermissions) Apply(server raft.Server) (interface{}, error)

func (*ChangeDbUserPermissions) CommandName 

func (c *ChangeDbUserPermissions) CommandName() string

type ClusterConsensus 

type ClusterConsensus interface {
	CreateDatabase(name string) error
	DropDatabase(name string) error
	DropSeries(database, series string) error
	CreateContinuousQuery(db string, query string) error
	DeleteContinuousQuery(db string, id uint32) error
	SaveClusterAdminUser(u *cluster.ClusterAdmin) error
	SaveDbUser(user *cluster.DbUser) error
	ChangeDbUserPassword(db, username string, hash []byte) error
	ChangeDbUserPermissions(db, username, readPermissions, writePermissions string) error
	AssignCoordinator(coordinator *CoordinatorImpl) error
	// When a cluster is turned on for the first time.
	CreateRootUser() error
	ForceLogCompaction() error
}

type ContinuousQueryWriter 

type ContinuousQueryWriter struct {
	// contains filtered or unexported fields
}

func NewContinuousQueryWriter 

func NewContinuousQueryWriter(yield func(*protocol.Series) error) *ContinuousQueryWriter

func (*ContinuousQueryWriter) Close 

func (self *ContinuousQueryWriter) Close()

func (*ContinuousQueryWriter) Write 

func (self *ContinuousQueryWriter) Write(series *protocol.Series) error

type Coordinator 

type Coordinator interface {
	// Assumption about the returned data:
	//   1. For any given time series, the points returned are in order
	//   2. If the query involves more than one time series, there is no
	//      guarantee on the order in whic they are returned
	//   3. Data is filtered, i.e. where clause should be assumed to hold true
	//      for all the data points that are returned
	//   4. The end of a time series is signaled by returning a series with no data points
	//   5. TODO: Aggregation on the nodes
	WriteSeriesData(user common.User, db string, series []*protocol.Series) error
	DropDatabase(user common.User, db string) error
	CreateDatabase(user common.User, db string) error
	ForceCompaction(user common.User) error
	ListDatabases(user common.User) ([]*cluster.Database, error)
	DeleteContinuousQuery(user common.User, db string, id uint32) error
	CreateContinuousQuery(user common.User, db string, query string) error
	ListContinuousQueries(user common.User, db string) ([]*protocol.Series, error)

	// v2 clustering, based on sharding instead of the circular hash ring
	RunQuery(user common.User, db, query string, seriesWriter SeriesWriter) error
}

type CoordinatorImpl 

type CoordinatorImpl struct {
	// contains filtered or unexported fields
}

func NewCoordinatorImpl 

func NewCoordinatorImpl(
	config *configuration.Configuration,
	raftServer ClusterConsensus,
	clusterConfiguration *cluster.ClusterConfiguration,
	metastore Metastore) *CoordinatorImpl

func (*CoordinatorImpl) AuthenticateClusterAdmin 

func (self *CoordinatorImpl) AuthenticateClusterAdmin(username, password string) (common.User, error)

func (*CoordinatorImpl) AuthenticateDbUser 

func (self *CoordinatorImpl) AuthenticateDbUser(db, username, password string) (common.User, error)

func (*CoordinatorImpl) ChangeClusterAdminPassword 

func (self *CoordinatorImpl) ChangeClusterAdminPassword(requester common.User, username, password string) error

func (*CoordinatorImpl) ChangeDbUserPassword 

func (self *CoordinatorImpl) ChangeDbUserPassword(requester common.User, db, username, password string) error

func (*CoordinatorImpl) ChangeDbUserPermissions 

func (self *CoordinatorImpl) ChangeDbUserPermissions(requester common.User, db, username, readPermissions, writePermissions string) error

func (*CoordinatorImpl) CommitSeriesData 

func (self *CoordinatorImpl) CommitSeriesData(db string, serieses []*protocol.Series, sync bool) error

func (*CoordinatorImpl) ConnectToProtobufServers 

func (self *CoordinatorImpl) ConnectToProtobufServers(localRaftName string) error

func (*CoordinatorImpl) CreateClusterAdminUser 

func (self *CoordinatorImpl) CreateClusterAdminUser(requester common.User, username, password string) error

func (*CoordinatorImpl) CreateContinuousQuery 

func (self *CoordinatorImpl) CreateContinuousQuery(user common.User, db string, query string) error

func (*CoordinatorImpl) CreateDatabase 

func (self *CoordinatorImpl) CreateDatabase(user common.User, db string) error

func (*CoordinatorImpl) CreateDbUser 

func (self *CoordinatorImpl) CreateDbUser(requester common.User, db, username, password string, permissions ...string) error

func (*CoordinatorImpl) DeleteClusterAdminUser 

func (self *CoordinatorImpl) DeleteClusterAdminUser(requester common.User, username string) error

func (*CoordinatorImpl) DeleteContinuousQuery 

func (self *CoordinatorImpl) DeleteContinuousQuery(user common.User, db string, id uint32) error

func (*CoordinatorImpl) DeleteDbUser 

func (self *CoordinatorImpl) DeleteDbUser(requester common.User, db, username string) error

func (*CoordinatorImpl) DropDatabase 

func (self *CoordinatorImpl) DropDatabase(user common.User, db string) error

func (*CoordinatorImpl) ForceCompaction 

func (self *CoordinatorImpl) ForceCompaction(user common.User) error

func (*CoordinatorImpl) GetDbUser 

func (self *CoordinatorImpl) GetDbUser(requester common.User, db string, username string) (common.User, error)

func (*CoordinatorImpl) InterpolateValuesAndCommit 

func (self *CoordinatorImpl) InterpolateValuesAndCommit(query string, db string, series *protocol.Series, targetName string, assignSequenceNumbers bool) error

func (*CoordinatorImpl) ListClusterAdmins 

func (self *CoordinatorImpl) ListClusterAdmins(requester common.User) ([]string, error)

func (*CoordinatorImpl) ListContinuousQueries 

func (self *CoordinatorImpl) ListContinuousQueries(user common.User, db string) ([]*protocol.Series, error)

func (*CoordinatorImpl) ListDatabases 

func (self *CoordinatorImpl) ListDatabases(user common.User) ([]*cluster.Database, error)

func (*CoordinatorImpl) ListDbUsers 

func (self *CoordinatorImpl) ListDbUsers(requester common.User, db string) ([]common.User, error)

func (*CoordinatorImpl) ProcessContinuousQueries 

func (self *CoordinatorImpl) ProcessContinuousQueries(db string, series *protocol.Series)

func (*CoordinatorImpl) RunQuery 

func (self *CoordinatorImpl) RunQuery(user common.User, database string, queryString string, seriesWriter SeriesWriter) (err error)

func (*CoordinatorImpl) SetDbAdmin 

func (self *CoordinatorImpl) SetDbAdmin(requester common.User, db, username string, isAdmin bool) error

func (*CoordinatorImpl) WriteSeriesData 

func (self *CoordinatorImpl) WriteSeriesData(user common.User, db string, series []*protocol.Series) error

type CreateContinuousQueryCommand 

type CreateContinuousQueryCommand struct {
	Database string `json:"database"`
	Query    string `json:"query"`
}

func NewCreateContinuousQueryCommand 

func NewCreateContinuousQueryCommand(database string, query string) *CreateContinuousQueryCommand

func (*CreateContinuousQueryCommand) Apply 

func (c *CreateContinuousQueryCommand) Apply(server raft.Server) (interface{}, error)

func (*CreateContinuousQueryCommand) CommandName 

func (c *CreateContinuousQueryCommand) CommandName() string

type CreateDatabaseCommand 

type CreateDatabaseCommand struct {
	Name string `json:"name"`
}

func NewCreateDatabaseCommand 

func NewCreateDatabaseCommand(name string) *CreateDatabaseCommand

func (*CreateDatabaseCommand) Apply 

func (c *CreateDatabaseCommand) Apply(server raft.Server) (interface{}, error)

func (*CreateDatabaseCommand) CommandName 

func (c *CreateDatabaseCommand) CommandName() string

type CreateSeriesFieldIdsCommand 

type CreateSeriesFieldIdsCommand struct {
	Database string
	Series   []*protocol.Series
}

func NewCreateSeriesFieldIdsCommand 

func NewCreateSeriesFieldIdsCommand(database string, series []*protocol.Series) *CreateSeriesFieldIdsCommand

func (*CreateSeriesFieldIdsCommand) Apply 

func (c *CreateSeriesFieldIdsCommand) Apply(server raft.Server) (interface{}, error)

func (*CreateSeriesFieldIdsCommand) CommandName 

func (c *CreateSeriesFieldIdsCommand) CommandName() string

func (*CreateSeriesFieldIdsCommand) Decode 

func (c *CreateSeriesFieldIdsCommand) Decode(r io.Reader) error

func (*CreateSeriesFieldIdsCommand) Encode 

func (c *CreateSeriesFieldIdsCommand) Encode(w io.Writer) error

type CreateShardSpaceCommand 

type CreateShardSpaceCommand struct {
	ShardSpace *cluster.ShardSpace
}

func NewCreateShardSpaceCommand 

func NewCreateShardSpaceCommand(space *cluster.ShardSpace) *CreateShardSpaceCommand

func (*CreateShardSpaceCommand) Apply 

func (c *CreateShardSpaceCommand) Apply(server raft.Server) (interface{}, error)

func (*CreateShardSpaceCommand) CommandName 

func (c *CreateShardSpaceCommand) CommandName() string

type CreateShardsCommand 

type CreateShardsCommand struct {
	Shards    []*cluster.NewShardData
	SpaceName string
}

func NewCreateShardsCommand 

func NewCreateShardsCommand(shards []*cluster.NewShardData) *CreateShardsCommand

func (*CreateShardsCommand) Apply 

func (c *CreateShardsCommand) Apply(server raft.Server) (interface{}, error)

func (*CreateShardsCommand) CommandName 

func (c *CreateShardsCommand) CommandName() string

func (*CreateShardsCommand) Decode 

func (c *CreateShardsCommand) Decode(r io.Reader) error

func (*CreateShardsCommand) Encode 

func (c *CreateShardsCommand) Encode(w io.Writer) error

type DeleteContinuousQueryCommand 

type DeleteContinuousQueryCommand struct {
	Database string `json:"database"`
	Id       uint32 `json:"id"`
}

func NewDeleteContinuousQueryCommand 

func NewDeleteContinuousQueryCommand(database string, id uint32) *DeleteContinuousQueryCommand

func (*DeleteContinuousQueryCommand) Apply 

func (c *DeleteContinuousQueryCommand) Apply(server raft.Server) (interface{}, error)

func (*DeleteContinuousQueryCommand) CommandName 

func (c *DeleteContinuousQueryCommand) CommandName() string

type DropDatabaseCommand 

type DropDatabaseCommand struct {
	Name string `json:"name"`
}

func NewDropDatabaseCommand 

func NewDropDatabaseCommand(name string) *DropDatabaseCommand

func (*DropDatabaseCommand) Apply 

func (c *DropDatabaseCommand) Apply(server raft.Server) (interface{}, error)

func (*DropDatabaseCommand) CommandName 

func (c *DropDatabaseCommand) CommandName() string

type DropSeriesCommand 

type DropSeriesCommand struct {
	Database string
	Series   string
}

func NewDropSeriesCommand 

func NewDropSeriesCommand(database, series string) *DropSeriesCommand

func (*DropSeriesCommand) Apply 

func (c *DropSeriesCommand) Apply(server raft.Server) (interface{}, error)

func (*DropSeriesCommand) CommandName 

func (c *DropSeriesCommand) CommandName() string

type DropShardCommand 

type DropShardCommand struct {
	ShardId   uint32
	ServerIds []uint32
}

func NewDropShardCommand 

func NewDropShardCommand(id uint32, serverIds []uint32) *DropShardCommand

func (*DropShardCommand) Apply 

func (c *DropShardCommand) Apply(server raft.Server) (interface{}, error)

func (*DropShardCommand) CommandName 

func (c *DropShardCommand) CommandName() string

type DropShardSpaceCommand 

type DropShardSpaceCommand struct {
	Database string
	Name     string
}

func NewDropShardSpaceCommand 

func NewDropShardSpaceCommand(database, name string) *DropShardSpaceCommand

func (*DropShardSpaceCommand) Apply 

func (c *DropShardSpaceCommand) Apply(server raft.Server) (interface{}, error)

func (*DropShardSpaceCommand) CommandName 

func (c *DropShardSpaceCommand) CommandName() string

type InfluxChangeConnectionStringCommand 

type InfluxChangeConnectionStringCommand struct {
	Name                     string `json:"name"`
	Force                    bool   `json:"force"`
	ConnectionString         string `json:"connectionString"`
	ProtobufConnectionString string `json:"protobufConnectionString"`
}

func (*InfluxChangeConnectionStringCommand) Apply 

func (c *InfluxChangeConnectionStringCommand) Apply(server raft.Server) (interface{}, error)

func (*InfluxChangeConnectionStringCommand) CommandName 

func (c *InfluxChangeConnectionStringCommand) CommandName() string

The name of the ChangeConnectionString command in the log

func (*InfluxChangeConnectionStringCommand) NodeName 

func (c *InfluxChangeConnectionStringCommand) NodeName() string

type InfluxForceLeaveCommand 

type InfluxForceLeaveCommand struct {
	Id uint32 `json:"id"`
}

func (*InfluxForceLeaveCommand) Apply 

func (c *InfluxForceLeaveCommand) Apply(server raft.Server) (interface{}, error)

func (*InfluxForceLeaveCommand) CommandName 

func (c *InfluxForceLeaveCommand) CommandName() string

The name of the ForceLeave command in the log

type InfluxJoinCommand 

type InfluxJoinCommand struct {
	Name                     string `json:"name"`
	ConnectionString         string `json:"connectionString"`
	ProtobufConnectionString string `json:"protobufConnectionString"`
}

func (*InfluxJoinCommand) Apply 

func (c *InfluxJoinCommand) Apply(server raft.Server) (interface{}, error)

func (*InfluxJoinCommand) CommandName 

func (c *InfluxJoinCommand) CommandName() string

The name of the Join command in the log

func (*InfluxJoinCommand) NodeName 

func (c *InfluxJoinCommand) NodeName() string

type Metastore 

type Metastore interface {
	ReplaceFieldNamesWithFieldIds(database string, series []*protocol.Series) error
}

type Permissions 

type Permissions struct{}

func (*Permissions) AuthorizeChangeClusterAdminPassword 

func (self *Permissions) AuthorizeChangeClusterAdminPassword(user common.User) (ok bool, err common.AuthorizationError)

func (*Permissions) AuthorizeChangeDbUserPassword 

func (self *Permissions) AuthorizeChangeDbUserPassword(user common.User, db string, targetUsername string) (ok bool, err common.AuthorizationError)

func (*Permissions) AuthorizeChangeDbUserPermissions 

func (self *Permissions) AuthorizeChangeDbUserPermissions(user common.User, db string) (ok bool, err common.AuthorizationError)

func (*Permissions) AuthorizeCreateClusterAdmin 

func (self *Permissions) AuthorizeCreateClusterAdmin(user common.User) (ok bool, err common.AuthorizationError)

func (*Permissions) AuthorizeCreateContinuousQuery 

func (self *Permissions) AuthorizeCreateContinuousQuery(user common.User, db string) (ok bool, err common.AuthorizationError)

func (*Permissions) AuthorizeCreateDatabase 

func (self *Permissions) AuthorizeCreateDatabase(user common.User) (ok bool, err common.AuthorizationError)

func (*Permissions) AuthorizeCreateDbUser 

func (self *Permissions) AuthorizeCreateDbUser(user common.User, db string) (ok bool, err common.AuthorizationError)

func (*Permissions) AuthorizeDeleteClusterAdmin 

func (self *Permissions) AuthorizeDeleteClusterAdmin(user common.User) (ok bool, err common.AuthorizationError)

func (*Permissions) AuthorizeDeleteContinuousQuery 

func (self *Permissions) AuthorizeDeleteContinuousQuery(user common.User, db string) (ok bool, err common.AuthorizationError)

func (*Permissions) AuthorizeDeleteDbUser 

func (self *Permissions) AuthorizeDeleteDbUser(user common.User, db string) (ok bool, err common.AuthorizationError)

func (*Permissions) AuthorizeDeleteQuery 

func (self *Permissions) AuthorizeDeleteQuery(user common.User, db string) (ok bool, err common.AuthorizationError)

func (*Permissions) AuthorizeDropDatabase 

func (self *Permissions) AuthorizeDropDatabase(user common.User) (ok bool, err common.AuthorizationError)

func (*Permissions) AuthorizeDropSeries 

func (self *Permissions) AuthorizeDropSeries(user common.User, db string, seriesName string) (ok bool, err common.AuthorizationError)

func (*Permissions) AuthorizeGetDbUser 

func (self *Permissions) AuthorizeGetDbUser(user common.User, db string) (ok bool, err common.AuthorizationError)

func (*Permissions) AuthorizeGrantDbUserAdmin 

func (self *Permissions) AuthorizeGrantDbUserAdmin(user common.User, db string) (ok bool, err common.AuthorizationError)

func (*Permissions) AuthorizeListClusterAdmins 

func (self *Permissions) AuthorizeListClusterAdmins(user common.User) (ok bool, err common.AuthorizationError)

func (*Permissions) AuthorizeListContinuousQueries 

func (self *Permissions) AuthorizeListContinuousQueries(user common.User, db string) (ok bool, err common.AuthorizationError)

func (*Permissions) AuthorizeListDatabases 

func (self *Permissions) AuthorizeListDatabases(user common.User) (ok bool, err common.AuthorizationError)

func (*Permissions) AuthorizeListDbUsers 

func (self *Permissions) AuthorizeListDbUsers(user common.User, db string) (ok bool, err common.AuthorizationError)

type ProtobufClient 

type ProtobufClient struct {
	// contains filtered or unexported fields
}

func NewProtobufClient 

func NewProtobufClient(hostAndPort string, writeTimeout time.Duration) *ProtobufClient

func (*ProtobufClient) ClearRequests 

func (self *ProtobufClient) ClearRequests()

func (*ProtobufClient) Close 

func (self *ProtobufClient) Close()

func (*ProtobufClient) Connect 

func (self *ProtobufClient) Connect()

func (*ProtobufClient) MakeRequest 

func (self *ProtobufClient) MakeRequest(request *protocol.Request, responseStream chan *protocol.Response) error

Makes a request to the server. If the responseStream chan is not nil it will expect a response from the server with a matching request.Id. The REQUEST_RETRY_ATTEMPTS constant of 3 and the RECONNECT_RETRY_WAIT of 100ms means that an attempt to make a request to a downed server will take 300ms to time out.

type ProtobufRequestHandler 

type ProtobufRequestHandler struct {
	// contains filtered or unexported fields
}

func NewProtobufRequestHandler 

func NewProtobufRequestHandler(coordinator Coordinator, clusterConfig *cluster.ClusterConfiguration) *ProtobufRequestHandler

func (*ProtobufRequestHandler) HandleRequest 

func (self *ProtobufRequestHandler) HandleRequest(request *protocol.Request, conn net.Conn) error

func (*ProtobufRequestHandler) WriteResponse 

func (self *ProtobufRequestHandler) WriteResponse(conn net.Conn, response *protocol.Response) error

type ProtobufServer 

type ProtobufServer struct {
	// contains filtered or unexported fields
}

func NewProtobufServer 

func NewProtobufServer(port string, requestHandler RequestHandler) *ProtobufServer

func (*ProtobufServer) Close 

func (self *ProtobufServer) Close()

func (*ProtobufServer) ListenAndServe 

func (self *ProtobufServer) ListenAndServe()

type RaftServer 

type RaftServer struct {
	// contains filtered or unexported fields
}

The raftd server is a combination of the Raft server and an HTTP server which acts as the transport.

func NewRaftServer 

func NewRaftServer(config *configuration.Configuration, clusterConfig *cluster.ClusterConfiguration) *RaftServer

Creates a new server.

func (*RaftServer) AssignCoordinator 

func (s *RaftServer) AssignCoordinator(coordinator *CoordinatorImpl) error

func (*RaftServer) ChangeConnectionString 

func (s *RaftServer) ChangeConnectionString(raftName, protobufConnectionString, raftConnectionString string, forced bool) error

func (*RaftServer) ChangeDbUserPassword 

func (s *RaftServer) ChangeDbUserPassword(db, username string, hash []byte) error

func (*RaftServer) ChangeDbUserPermissions 

func (s *RaftServer) ChangeDbUserPermissions(db, username, readPermissions, writePermissions string) error

func (*RaftServer) Close 

func (self *RaftServer) Close()

func (*RaftServer) CommittedAllChanges 

func (s *RaftServer) CommittedAllChanges() bool

func (*RaftServer) CompactLog 

func (s *RaftServer) CompactLog()

func (*RaftServer) CreateContinuousQuery 

func (s *RaftServer) CreateContinuousQuery(db string, query string) error

func (*RaftServer) CreateDatabase 

func (s *RaftServer) CreateDatabase(name string) error

func (*RaftServer) CreateRootUser 

func (s *RaftServer) CreateRootUser() error

func (*RaftServer) CreateShardSpace 

func (self *RaftServer) CreateShardSpace(shardSpace *cluster.ShardSpace) error

func (*RaftServer) CreateShards 

func (self *RaftServer) CreateShards(shards []*cluster.NewShardData) ([]*cluster.ShardData, error)

func (*RaftServer) DeleteContinuousQuery 

func (s *RaftServer) DeleteContinuousQuery(db string, id uint32) error

func (*RaftServer) DropDatabase 

func (s *RaftServer) DropDatabase(name string) error

func (*RaftServer) DropSeries 

func (self *RaftServer) DropSeries(database, series string) error

func (*RaftServer) DropShard 

func (self *RaftServer) DropShard(id uint32, serverIds []uint32) error

func (*RaftServer) DropShardSpace 

func (self *RaftServer) DropShardSpace(database, name string) error

func (*RaftServer) ForceLogCompaction 

func (s *RaftServer) ForceLogCompaction() error

func (*RaftServer) GetOrSetFieldIdsForSeries 

func (self *RaftServer) GetOrSetFieldIdsForSeries(database string, series []*protocol.Series) ([]*protocol.Series, error)

func (*RaftServer) GetRaftName 

func (s *RaftServer) GetRaftName() string

func (*RaftServer) HandleFunc 

func (s *RaftServer) HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request))

This is a hack around Gorilla mux not providing the correct net/http HandleFunc() interface.

func (*RaftServer) Join 

func (s *RaftServer) Join(leader string) error

Joins to the leader of an existing cluster.

func (*RaftServer) ListenAndServe 

func (s *RaftServer) ListenAndServe() error

func (*RaftServer) RemoveServer 

func (s *RaftServer) RemoveServer(id uint32) error

Joins to the leader of an existing cluster.

func (*RaftServer) SaveClusterAdminUser 

func (s *RaftServer) SaveClusterAdminUser(u *cluster.ClusterAdmin) error

func (*RaftServer) SaveDbUser 

func (s *RaftServer) SaveDbUser(u *cluster.DbUser) error

func (*RaftServer) Serve 

func (s *RaftServer) Serve(l net.Listener) error

func (*RaftServer) SetContinuousQueryTimestamp 

func (s *RaftServer) SetContinuousQueryTimestamp(timestamp time.Time) error

func (*RaftServer) StartProcessingContinuousQueries 

func (s *RaftServer) StartProcessingContinuousQueries()

type RequestHandler 

type RequestHandler interface {
	HandleRequest(request *protocol.Request, conn net.Conn) error
}

type SaveClusterAdminCommand 

type SaveClusterAdminCommand struct {
	User *cluster.ClusterAdmin `json:"user"`
}

func NewSaveClusterAdminCommand 

func NewSaveClusterAdminCommand(u *cluster.ClusterAdmin) *SaveClusterAdminCommand

func (*SaveClusterAdminCommand) Apply 

func (c *SaveClusterAdminCommand) Apply(server raft.Server) (interface{}, error)

func (*SaveClusterAdminCommand) CommandName 

func (c *SaveClusterAdminCommand) CommandName() string

type SaveDbUserCommand 

type SaveDbUserCommand struct {
	User *cluster.DbUser `json:"user"`
}

func NewSaveDbUserCommand 

func NewSaveDbUserCommand(u *cluster.DbUser) *SaveDbUserCommand

func (*SaveDbUserCommand) Apply 

func (c *SaveDbUserCommand) Apply(server raft.Server) (interface{}, error)

func (*SaveDbUserCommand) CommandName 

func (c *SaveDbUserCommand) CommandName() string

type SeriesWriter 

type SeriesWriter interface {
	Write(*protocol.Series) error
	Close()
}

type SetContinuousQueryTimestampCommand 

type SetContinuousQueryTimestampCommand struct {
	Timestamp time.Time `json:"timestamp"`
}

func NewSetContinuousQueryTimestampCommand 

func NewSetContinuousQueryTimestampCommand(timestamp time.Time) *SetContinuousQueryTimestampCommand

func (*SetContinuousQueryTimestampCommand) Apply 

func (c *SetContinuousQueryTimestampCommand) Apply(server raft.Server) (interface{}, error)

func (*SetContinuousQueryTimestampCommand) CommandName 

func (c *SetContinuousQueryTimestampCommand) CommandName() string

type ShardAwareObject 

type ShardAwareObject interface {
	GetShards(querySpec *parser.QuerySpec) []cluster.Shard
	// returns true if results from shards can just be ordered. false if the results are raw points that
	// need to be sent through the query engine
	CanCollateShards(querySpec *parser.QuerySpec) bool
	GetShardById(id uint32) cluster.Shard
	GetShardToWriteToBySeriesAndTime(db, series string, microsecondsEpoch int64) (cluster.Shard, error)
}

These are things that the Coordinator need (defined in Coordinator, will have to import cluster package)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.