▽

Get ActiveGo Get started Packages

Package structs

Constants

const (
    SessionTTLMax        = 24 * time.Hour
    SessionTTLMultiplier = 2
)

const (
    // QueryTemplateTypeNamePrefixMatch uses the Name field of the query as
    // a prefix to select the template.
    QueryTemplateTypeNamePrefixMatch = "name_prefix_match"
)

Variables

var (
    ErrNoLeader  = fmt.Errorf("No cluster leader")
    ErrNoDCPath  = fmt.Errorf("No path to datacenter")
    ErrNoServers = fmt.Errorf("No known Consul servers")
)

func Decode ¶

func Decode(buf []byte, out interface{}) error

Decode is used to decode a MsgPack encoded object

func Encode ¶

func Encode(t MessageType, msg interface{}) ([]byte, error)

Encode is used to encode a MsgPack object with type prefix

func SatisfiesMetaFilters ¶

func SatisfiesMetaFilters(meta map[string]string, filters map[string]string) bool

SatisfiesMetaFilters returns true if the metadata map contains the given filters

func ValidStatus ¶

func ValidStatus(s string) bool

func ValidateMetadata ¶

func ValidateMetadata(meta map[string]string) error

ValidateMeta validates a set of key/value pairs from the agent config

type ACL ¶

ACL is used to represent a token and its rules

type ACL struct {
    ID    string
    Name  string
    Type  string
    Rules string

    RaftIndex
}

func (*ACL) IsSame ¶

func (a *ACL) IsSame(other *ACL) bool

IsSame checks if one ACL is the same as another, without looking at the Raft information (that's why we didn't call it IsEqual). This is useful for seeing if an update would be idempotent for all the functional parts of the structure.

type ACLOp ¶

type ACLOp string

const (
    ACLSet      ACLOp = "set"
    ACLForceSet       = "force-set" // Deprecated, left to backwards compatibility
    ACLDelete         = "delete"
)

type ACLPolicy ¶

type ACLPolicy struct {
    ETag   string
    Parent string
    Policy *acl.Policy
    TTL    time.Duration
    QueryMeta
}

type ACLPolicyRequest ¶

ACLPolicyRequest is used to request an ACL by ID, conditionally filtering on an ID

type ACLPolicyRequest struct {
    Datacenter string
    ACL        string
    ETag       string
    QueryOptions
}

func (*ACLPolicyRequest) RequestDatacenter ¶

func (r *ACLPolicyRequest) RequestDatacenter() string

type ACLReplicationStatus ¶

ACLReplicationStatus provides information about the health of the ACL replication system.

type ACLReplicationStatus struct {
    Enabled          bool
    Running          bool
    SourceDatacenter string
    ReplicatedIndex  uint64
    LastSuccess      time.Time
    LastError        time.Time
}

type ACLRequest ¶

ACLRequest is used to create, update or delete an ACL

type ACLRequest struct {
    Datacenter string
    Op         ACLOp
    ACL        ACL
    WriteRequest
}

func (*ACLRequest) RequestDatacenter ¶

func (r *ACLRequest) RequestDatacenter() string

type ACLRequests ¶

ACLRequests is a list of ACL change requests.

type ACLRequests []*ACLRequest

type ACLSpecificRequest ¶

ACLSpecificRequest is used to request an ACL by ID

type ACLSpecificRequest struct {
    Datacenter string
    ACL        string
    QueryOptions
}

func (*ACLSpecificRequest) RequestDatacenter ¶

func (r *ACLSpecificRequest) RequestDatacenter() string

type ACLs ¶

type ACLs []*ACL

type AutopilotConfig ¶

AutopilotConfig holds the Autopilot configuration for a cluster.

type AutopilotConfig struct {
    // CleanupDeadServers controls whether to remove dead servers when a new
    // server is added to the Raft peers.
    CleanupDeadServers bool

    // LastContactThreshold is the limit on the amount of time a server can go
    // without leader contact before being considered unhealthy.
    LastContactThreshold time.Duration

    // MaxTrailingLogs is the amount of entries in the Raft Log that a server can
    // be behind before being considered unhealthy.
    MaxTrailingLogs uint64

    // ServerStabilizationTime is the minimum amount of time a server must be
    // in a stable, healthy state before it can be added to the cluster. Only
    // applicable with Raft protocol version 3 or higher.
    ServerStabilizationTime time.Duration

    // (Enterprise-only) RedundancyZoneTag is the node tag to use for separating
    // servers into zones for redundancy. If left blank, this feature will be disabled.
    RedundancyZoneTag string

    // (Enterprise-only) DisableUpgradeMigration will disable Autopilot's upgrade migration
    // strategy of waiting until enough newer-versioned servers have been added to the
    // cluster before promoting them to voters.
    DisableUpgradeMigration bool

    // RaftIndex stores the create/modify indexes of this configuration.
    RaftIndex
}

type AutopilotSetConfigRequest ¶

AutopilotSetConfigRequest is used by the Operator endpoint to update the current Autopilot configuration of the cluster.

type AutopilotSetConfigRequest struct {
    // Datacenter is the target this request is intended for.
    Datacenter string

    // Config is the new Autopilot configuration to use.
    Config AutopilotConfig

    // CAS controls whether to use check-and-set semantics for this request.
    CAS bool

    // WriteRequest holds the ACL token to go along with this request.
    WriteRequest
}

func (*AutopilotSetConfigRequest) RequestDatacenter ¶

func (op *AutopilotSetConfigRequest) RequestDatacenter() string

RequestDatacenter returns the datacenter for a given request.

type CheckServiceNode ¶

CheckServiceNode is used to provide the node, its service definition, as well as a HealthCheck that is associated.

type CheckServiceNode struct {
    Node    *Node
    Service *NodeService
    Checks  HealthChecks
}

type CheckServiceNodes ¶

type CheckServiceNodes []CheckServiceNode

func (CheckServiceNodes) Filter ¶

func (nodes CheckServiceNodes) Filter(onlyPassing bool) CheckServiceNodes

Filter removes nodes that are failing health checks (and any non-passing check if that option is selected). Note that this returns the filtered results AND modifies the receiver for performance.

func (CheckServiceNodes) Shuffle ¶

func (nodes CheckServiceNodes) Shuffle()

Shuffle does an in-place random shuffle using the Fisher-Yates algorithm.

type ChecksInStateRequest ¶

ChecksInStateRequest is used to query for nodes in a state

type ChecksInStateRequest struct {
    Datacenter      string
    NodeMetaFilters map[string]string
    State           string
    Source          QuerySource
    QueryOptions
}

func (*ChecksInStateRequest) RequestDatacenter ¶

func (r *ChecksInStateRequest) RequestDatacenter() string

type CompoundResponse ¶

CompoundResponse is an interface for gathering multiple responses. It is used in cross-datacenter RPC calls where more than 1 datacenter is expected to reply.

type CompoundResponse interface {
    // Add adds a new response to the compound response
    Add(interface{})

    // New returns an empty response object which can be passed around by
    // reference, and then passed to Add() later on.
    New() interface{}
}

type Coordinate ¶

Coordinate stores a node name with its associated network coordinate.

type Coordinate struct {
    Node  string
    Coord *coordinate.Coordinate
}

type CoordinateUpdateRequest ¶

CoordinateUpdateRequest is used to update the network coordinate of a given node.

type CoordinateUpdateRequest struct {
    Datacenter string
    Node       string
    Coord      *coordinate.Coordinate
    WriteRequest
}

func (*CoordinateUpdateRequest) RequestDatacenter ¶

func (c *CoordinateUpdateRequest) RequestDatacenter() string

RequestDatacenter returns the datacenter for a given update request.

type Coordinates ¶

type Coordinates []*Coordinate

type DCSpecificRequest ¶

DCSpecificRequest is used to query about a specific DC

type DCSpecificRequest struct {
    Datacenter      string
    NodeMetaFilters map[string]string
    Source          QuerySource
    QueryOptions
}

func (*DCSpecificRequest) RequestDatacenter ¶

func (r *DCSpecificRequest) RequestDatacenter() string

type DatacenterMap ¶

DatacenterMap is used to represent a list of nodes with their raw coordinates, associated with a datacenter. Coordinates are only compatible between nodes in the same area.

type DatacenterMap struct {
    Datacenter  string
    AreaID      types.AreaID
    Coordinates Coordinates
}

type DeregisterRequest ¶

DeregisterRequest is used for the Catalog.Deregister endpoint to deregister a node as providing a service. If no service is provided the entire node is deregistered.

type DeregisterRequest struct {
    Datacenter string
    Node       string
    ServiceID  string
    CheckID    types.CheckID
    WriteRequest
}

func (*DeregisterRequest) RequestDatacenter ¶

func (r *DeregisterRequest) RequestDatacenter() string

type DirEntries ¶

type DirEntries []*DirEntry

type DirEntry ¶

DirEntry is used to represent a directory entry. This is used for values in our Key-Value store.

type DirEntry struct {
    LockIndex uint64
    Key       string
    Flags     uint64
    Value     []byte
    Session   string `json:",omitempty"`

    RaftIndex
}

func (*DirEntry) Clone ¶

func (d *DirEntry) Clone() *DirEntry

Returns a clone of the given directory entry.

type EventFireRequest ¶

EventFireRequest is used to ask a server to fire a Serf event. It is a bit odd, since it doesn't depend on the catalog or leader. Any node can respond, so it's not quite like a standard write request. This is used only internally.

type EventFireRequest struct {
    Datacenter string
    Name       string
    Payload    []byte

    // Not using WriteRequest so that any server can process
    // the request. It is a bit unusual...
    QueryOptions
}

func (*EventFireRequest) RequestDatacenter ¶

func (r *EventFireRequest) RequestDatacenter() string

type EventFireResponse ¶

EventFireResponse is used to respond to a fire request.

type EventFireResponse struct {
    QueryMeta
}

type HealthCheck ¶

HealthCheck represents a single check on a given node

type HealthCheck struct {
    Node        string
    CheckID     types.CheckID // Unique per-node ID
    Name        string        // Check name
    Status      string        // The current check status
    Notes       string        // Additional notes with the status
    Output      string        // Holds output of script runs
    ServiceID   string        // optional associated service
    ServiceName string        // optional service name
    ServiceTags []string      // optional service tags

    RaftIndex
}

func (*HealthCheck) Clone ¶

func (c *HealthCheck) Clone() *HealthCheck

Clone returns a distinct clone of the HealthCheck.

func (*HealthCheck) IsSame ¶

func (c *HealthCheck) IsSame(other *HealthCheck) bool

IsSame checks if one HealthCheck is the same as another, without looking at the Raft information (that's why we didn't call it IsEqual). This is useful for seeing if an update would be idempotent for all the functional parts of the structure.

type HealthChecks ¶

HealthChecks is a collection of HealthCheck structs.

type HealthChecks []*HealthCheck

type IndexedACLs ¶

type IndexedACLs struct {
    ACLs ACLs
    QueryMeta
}

type IndexedCheckServiceNodes ¶

type IndexedCheckServiceNodes struct {
    Nodes CheckServiceNodes
    QueryMeta
}

type IndexedCoordinate ¶

IndexedCoordinate is used to represent a single node's coordinate from the state store.

type IndexedCoordinate struct {
    Coord *coordinate.Coordinate
    QueryMeta
}

type IndexedCoordinates ¶

IndexedCoordinates is used to represent a list of nodes and their corresponding raw coordinates.

type IndexedCoordinates struct {
    Coordinates Coordinates
    QueryMeta
}

type IndexedDirEntries ¶

type IndexedDirEntries struct {
    Entries DirEntries
    QueryMeta
}

type IndexedHealthChecks ¶

type IndexedHealthChecks struct {
    HealthChecks HealthChecks
    QueryMeta
}

type IndexedKeyList ¶

type IndexedKeyList struct {
    Keys []string
    QueryMeta
}

type IndexedNodeDump ¶

type IndexedNodeDump struct {
    Dump NodeDump
    QueryMeta
}

type IndexedNodeServices ¶

type IndexedNodeServices struct {
    NodeServices *NodeServices
    QueryMeta
}

type IndexedNodes ¶

type IndexedNodes struct {
    Nodes Nodes
    QueryMeta
}

type IndexedPreparedQueries ¶

type IndexedPreparedQueries struct {
    Queries PreparedQueries
    QueryMeta
}

type IndexedServiceNodes ¶

type IndexedServiceNodes struct {
    ServiceNodes ServiceNodes
    QueryMeta
}

type IndexedServices ¶

type IndexedServices struct {
    Services Services
    QueryMeta
}

type IndexedSessions ¶

type IndexedSessions struct {
    Sessions Sessions
    QueryMeta
}

type KVSRequest ¶

KVSRequest is used to operate on the Key-Value store

type KVSRequest struct {
    Datacenter string
    Op         api.KVOp // Which operation are we performing
    DirEnt     DirEntry // Which directory entry
    WriteRequest
}

func (*KVSRequest) RequestDatacenter ¶

func (r *KVSRequest) RequestDatacenter() string

type KeyListRequest ¶

KeyListRequest is used to list keys

type KeyListRequest struct {
    Datacenter string
    Prefix     string
    Seperator  string
    QueryOptions
}

func (*KeyListRequest) RequestDatacenter ¶

func (r *KeyListRequest) RequestDatacenter() string

type KeyRequest ¶

KeyRequest is used to request a key, or key prefix

type KeyRequest struct {
    Datacenter string
    Key        string
    QueryOptions
}

func (*KeyRequest) RequestDatacenter ¶

func (r *KeyRequest) RequestDatacenter() string

type KeyringOp ¶

type KeyringOp string

const (
    KeyringList    KeyringOp = "list"
    KeyringInstall           = "install"
    KeyringUse               = "use"
    KeyringRemove            = "remove"
)

type KeyringRequest ¶

KeyringRequest encapsulates a request to modify an encryption keyring. It can be used for install, remove, or use key type operations.

type KeyringRequest struct {
    Operation   KeyringOp
    Key         string
    Datacenter  string
    Forwarded   bool
    RelayFactor uint8
    QueryOptions
}

func (*KeyringRequest) RequestDatacenter ¶

func (r *KeyringRequest) RequestDatacenter() string

type KeyringResponse ¶

KeyringResponse is a unified key response and can be used for install, remove, use, as well as listing key queries.

type KeyringResponse struct {
    WAN        bool
    Datacenter string
    Messages   map[string]string `json:",omitempty"`
    Keys       map[string]int
    NumNodes   int
    Error      string `json:",omitempty"`
}

type KeyringResponses ¶

KeyringResponses holds multiple responses to keyring queries. Each datacenter replies independently, and KeyringResponses is used as a container for the set of all responses.

type KeyringResponses struct {
    Responses []*KeyringResponse
    QueryMeta
}

func (*KeyringResponses) Add ¶

func (r *KeyringResponses) Add(v interface{})

func (*KeyringResponses) New ¶

func (r *KeyringResponses) New() interface{}

type MessageType ¶

type MessageType uint8

const (
    RegisterRequestType MessageType = iota
    DeregisterRequestType
    KVSRequestType
    SessionRequestType
    ACLRequestType
    TombstoneRequestType
    CoordinateBatchUpdateType
    PreparedQueryRequestType
    TxnRequestType
    AutopilotRequestType
    AreaRequestType
)

const (
    // IgnoreUnknownTypeFlag is set along with a MessageType
    // to indicate that the message type can be safely ignored
    // if it is not recognized. This is for future proofing, so
    // that new commands can be added in a way that won't cause
    // old servers to crash when the FSM attempts to process them.
    IgnoreUnknownTypeFlag MessageType = 128

    // NodeMaint is the special key set by a node in maintenance mode.
    NodeMaint = "_node_maintenance"

    // ServiceMaintPrefix is the prefix for a service in maintenance mode.
    ServiceMaintPrefix = "_service_maintenance:"

    // Client tokens have rules applied
    ACLTypeClient = "client"

    // Management tokens have an always allow policy.
    // They are used for token management.
    ACLTypeManagement = "management"

    // MaxLockDelay provides a maximum LockDelay value for
    // a session. Any value above this will not be respected.
    MaxLockDelay = 60 * time.Second
)

type Node ¶

Used to return information about a node

type Node struct {
    ID              types.NodeID
    Node            string
    Address         string
    Datacenter      string
    TaggedAddresses map[string]string
    Meta            map[string]string

    RaftIndex
}

type NodeDump ¶

NodeDump is used to dump all the nodes with all their associated data. This is currently used for the UI only, as it is rather expensive to generate.

type NodeDump []*NodeInfo

type NodeInfo ¶

NodeInfo is used to dump all associated information about a node. This is currently used for the UI only, as it is rather expensive to generate.

type NodeInfo struct {
    ID              types.NodeID
    Node            string
    Address         string
    TaggedAddresses map[string]string
    Meta            map[string]string
    Services        []*NodeService
    Checks          HealthChecks
}

type NodeService ¶

NodeService is a service provided by a node

type NodeService struct {
    ID                string
    Service           string
    Tags              []string
    Address           string
    Port              int
    EnableTagOverride bool

    RaftIndex
}

func (*NodeService) IsSame ¶

func (s *NodeService) IsSame(other *NodeService) bool

IsSame checks if one NodeService is the same as another, without looking at the Raft information (that's why we didn't call it IsEqual). This is useful for seeing if an update would be idempotent for all the functional parts of the structure.

func (*NodeService) ToServiceNode ¶

func (s *NodeService) ToServiceNode(node string) *ServiceNode

ToServiceNode converts the given node service to a service node.

type NodeServices ¶

type NodeServices struct {
    Node     *Node
    Services map[string]*NodeService
}

type NodeSpecificRequest ¶

NodeSpecificRequest is used to request the information about a single node

type NodeSpecificRequest struct {
    Datacenter string
    Node       string
    QueryOptions
}

func (*NodeSpecificRequest) RequestDatacenter ¶

func (r *NodeSpecificRequest) RequestDatacenter() string

type Nodes ¶

type Nodes []*Node

type OperatorHealthReply ¶

OperatorHealthReply is a representation of the overall health of the cluster

type OperatorHealthReply struct {
    // Healthy is true if all the servers in the cluster are healthy.
    Healthy bool

    // FailureTolerance is the number of healthy servers that could be lost without
    // an outage occurring.
    FailureTolerance int

    // Servers holds the health of each server.
    Servers []ServerHealth
}

type PreparedQueries ¶

type PreparedQueries []*PreparedQuery

type PreparedQuery ¶

PreparedQuery defines a complete prepared query, and is the structure we maintain in the state store.

type PreparedQuery struct {
    // ID is this UUID-based ID for the query, always generated by Consul.
    ID string

    // Name is an optional friendly name for the query supplied by the
    // user. NOTE - if this feature is used then it will reduce the security
    // of any read ACL associated with this query/service since this name
    // can be used to locate nodes with supplying any ACL.
    Name string

    // Session is an optional session to tie this query's lifetime to. If
    // this is omitted then the query will not expire.
    Session string

    // Token is the ACL token used when the query was created, and it is
    // used when a query is subsequently executed. This token, or a token
    // with management privileges, must be used to change the query later.
    Token string

    // Template is used to configure this query as a template, which will
    // respond to queries based on the Name, and then will be rendered
    // before it is executed.
    Template QueryTemplateOptions

    // Service defines a service query (leaving things open for other types
    // later).
    Service ServiceQuery

    // DNS has options that control how the results of this query are
    // served over DNS.
    DNS QueryDNSOptions

    RaftIndex
}

func (*PreparedQuery) GetACLPrefix ¶

func (pq *PreparedQuery) GetACLPrefix() (string, bool)

GetACLPrefix returns the prefix to look up the prepared_query ACL policy for this query, and whether the prefix applies to this query. You always need to check the ok value before using the prefix.

type PreparedQueryExecuteRemoteRequest ¶

PreparedQueryExecuteRemoteRequest is used when running a local query in a remote datacenter.

type PreparedQueryExecuteRemoteRequest struct {
    // Datacenter is the target this request is intended for.
    Datacenter string

    // Query is a copy of the query to execute.  We have to ship the entire
    // query over since it won't be present in the remote state store.
    Query PreparedQuery

    // Limit will trim the resulting list down to the given limit.
    Limit int

    // QueryOptions (unfortunately named here) controls the consistency
    // settings for the the service lookups.
    QueryOptions
}

func (*PreparedQueryExecuteRemoteRequest) RequestDatacenter ¶

func (q *PreparedQueryExecuteRemoteRequest) RequestDatacenter() string

RequestDatacenter returns the datacenter for a given request.

type PreparedQueryExecuteRequest ¶

PreparedQueryExecuteRequest is used to execute a prepared query.

type PreparedQueryExecuteRequest struct {
    // Datacenter is the target this request is intended for.
    Datacenter string

    // QueryIDOrName is the ID of a query _or_ the name of one, either can
    // be provided.
    QueryIDOrName string

    // Limit will trim the resulting list down to the given limit.
    Limit int

    // Source is used to sort the results relative to a given node using
    // network coordinates.
    Source QuerySource

    // Agent is used to carry around a reference to the agent which initiated
    // the execute request. Used to distance-sort relative to the local node.
    Agent QuerySource

    // QueryOptions (unfortunately named here) controls the consistency
    // settings for the query lookup itself, as well as the service lookups.
    QueryOptions
}

func (*PreparedQueryExecuteRequest) RequestDatacenter ¶

func (q *PreparedQueryExecuteRequest) RequestDatacenter() string

RequestDatacenter returns the datacenter for a given request.

type PreparedQueryExecuteResponse ¶

PreparedQueryExecuteResponse has the results of executing a query.

type PreparedQueryExecuteResponse struct {
    // Service is the service that was queried.
    Service string

    // Nodes has the nodes that were output by the query.
    Nodes CheckServiceNodes

    // DNS has the options for serving these results over DNS.
    DNS QueryDNSOptions

    // Datacenter is the datacenter that these results came from.
    Datacenter string

    // Failovers is a count of how many times we had to query a remote
    // datacenter.
    Failovers int

    // QueryMeta has freshness information about the query.
    QueryMeta
}

type PreparedQueryExplainResponse ¶

PreparedQueryExplainResponse has the results when explaining a query/

type PreparedQueryExplainResponse struct {
    // Query has the fully-rendered query.
    Query PreparedQuery

    // QueryMeta has freshness information about the query.
    QueryMeta
}

type PreparedQueryOp ¶

type PreparedQueryOp string

const (
    PreparedQueryCreate PreparedQueryOp = "create"
    PreparedQueryUpdate PreparedQueryOp = "update"
    PreparedQueryDelete PreparedQueryOp = "delete"
)

type PreparedQueryRequest ¶

QueryRequest is used to create or change prepared queries.

type PreparedQueryRequest struct {
    // Datacenter is the target this request is intended for.
    Datacenter string

    // Op is the operation to apply.
    Op PreparedQueryOp

    // Query is the query itself.
    Query *PreparedQuery

    // WriteRequest holds the ACL token to go along with this request.
    WriteRequest
}

func (*PreparedQueryRequest) RequestDatacenter ¶

func (q *PreparedQueryRequest) RequestDatacenter() string

RequestDatacenter returns the datacenter for a given request.

type PreparedQuerySpecificRequest ¶

PreparedQuerySpecificRequest is used to get information about a prepared query.

type PreparedQuerySpecificRequest struct {
    // Datacenter is the target this request is intended for.
    Datacenter string

    // QueryID is the ID of a query.
    QueryID string

    // QueryOptions (unfortunately named here) controls the consistency
    // settings for the query lookup itself, as well as the service lookups.
    QueryOptions
}

func (*PreparedQuerySpecificRequest) RequestDatacenter ¶

func (q *PreparedQuerySpecificRequest) RequestDatacenter() string

RequestDatacenter returns the datacenter for a given request.

type QueryDNSOptions ¶

QueryDNSOptions controls settings when query results are served over DNS.

type QueryDNSOptions struct {
    // TTL is the time to live for the served DNS results.
    TTL string
}

type QueryDatacenterOptions ¶

QueryDatacenterOptions sets options about how we fail over if there are no healthy nodes in the local datacenter.

type QueryDatacenterOptions struct {
    // NearestN is set to the number of remote datacenters to try, based on
    // network coordinates.
    NearestN int

    // Datacenters is a fixed list of datacenters to try after NearestN. We
    // never try a datacenter multiple times, so those are subtracted from
    // this list before proceeding.
    Datacenters []string
}

type QueryMeta ¶

QueryMeta allows a query response to include potentially useful metadata about a query

type QueryMeta struct {
    // This is the index associated with the read
    Index uint64

    // If AllowStale is used, this is time elapsed since
    // last contact between the follower and leader. This
    // can be used to gauge staleness.
    LastContact time.Duration

    // Used to indicate if there is a known leader node
    KnownLeader bool
}

type QueryOptions ¶

QueryOptions is used to specify various flags for read queries

type QueryOptions struct {
    // Token is the ACL token ID. If not provided, the 'anonymous'
    // token is assumed for backwards compatibility.
    Token string

    // If set, wait until query exceeds given index. Must be provided
    // with MaxQueryTime.
    MinQueryIndex uint64

    // Provided with MinQueryIndex to wait for change.
    MaxQueryTime time.Duration

    // If set, any follower can service the request. Results
    // may be arbitrarily stale.
    AllowStale bool

    // If set, the leader must verify leadership prior to
    // servicing the request. Prevents a stale read.
    RequireConsistent bool
}

func (QueryOptions) ACLToken ¶

func (q QueryOptions) ACLToken() string

func (QueryOptions) AllowStaleRead ¶

func (q QueryOptions) AllowStaleRead() bool

func (QueryOptions) IsRead ¶

func (q QueryOptions) IsRead() bool

IsRead is always true for QueryOption.

type QuerySource ¶

QuerySource is used to pass along information about the source node in queries so that we can adjust the response based on its network coordinates.

type QuerySource struct {
    Datacenter string
    Node       string
}

type QueryTemplateOptions ¶

QueryTemplateOptions controls settings if this query is a template.

type QueryTemplateOptions struct {
    // Type, if non-empty, means that this query is a template. This is
    // set to one of the QueryTemplateType* constants above.
    Type string

    // Regexp is an optional regular expression to use to parse the full
    // name, once the prefix match has selected a template. This can be
    // used to extract parts of the name and choose a service name, set
    // tags, etc.
    Regexp string
}

type RPCInfo ¶

RPCInfo is used to describe common information about query

type RPCInfo interface {
    RequestDatacenter() string
    IsRead() bool
    AllowStaleRead() bool
    ACLToken() string
}

type RaftConfigurationResponse ¶

RaftConfigrationResponse is returned when querying for the current Raft configuration.

type RaftConfigurationResponse struct {
    // Servers has the list of servers in the Raft configuration.
    Servers []*RaftServer

    // Index has the Raft index of this configuration.
    Index uint64
}

type RaftIndex ¶

RaftIndex is used to track the index used while creating or modifying a given struct type.

type RaftIndex struct {
    CreateIndex uint64
    ModifyIndex uint64
}

type RaftRemovePeerRequest ¶

RaftRemovePeerRequest is used by the Operator endpoint to apply a Raft operation on a specific Raft peer by address in the form of "IP:port".

type RaftRemovePeerRequest struct {
    // Datacenter is the target this request is intended for.
    Datacenter string

    // Address is the peer to remove, in the form "IP:port".
    Address raft.ServerAddress

    // ID is the peer ID to remove.
    ID raft.ServerID

    // WriteRequest holds the ACL token to go along with this request.
    WriteRequest
}

func (*RaftRemovePeerRequest) RequestDatacenter ¶

func (op *RaftRemovePeerRequest) RequestDatacenter() string

RequestDatacenter returns the datacenter for a given request.

type RaftServer ¶

RaftServer has information about a server in the Raft configuration.

type RaftServer struct {
    // ID is the unique ID for the server. These are currently the same
    // as the address, but they will be changed to a real GUID in a future
    // release of Consul.
    ID raft.ServerID

    // Node is the node name of the server, as known by Consul, or this
    // will be set to "(unknown)" otherwise.
    Node string

    // Address is the IP:port of the server, used for Raft communications.
    Address raft.ServerAddress

    // Leader is true if this server is the current cluster leader.
    Leader bool

    // Voter is true if this server has a vote in the cluster. This might
    // be false if the server is staging and still coming online, or if
    // it's a non-voting server, which will be added in a future release of
    // Consul.
    Voter bool
}

type RegisterRequest ¶

RegisterRequest is used for the Catalog.Register endpoint to register a node as providing a service. If no service is provided, the node is registered.

type RegisterRequest struct {
    Datacenter      string
    ID              types.NodeID
    Node            string
    Address         string
    TaggedAddresses map[string]string
    NodeMeta        map[string]string
    Service         *NodeService
    Check           *HealthCheck
    Checks          HealthChecks

    // SkipNodeUpdate can be used when a register request is intended for
    // updating a service and/or checks, but doesn't want to overwrite any
    // node information if the node is already registered. If the node
    // doesn't exist, it will still be created, but if the node exists, any
    // node portion of this update will not apply.
    SkipNodeUpdate bool

    WriteRequest
}

func (*RegisterRequest) ChangesNode ¶

func (r *RegisterRequest) ChangesNode(node *Node) bool

ChangesNode returns true if the given register request changes the given node, which can be nil. This only looks for changes to the node record itself, not any of the health checks.

func (*RegisterRequest) RequestDatacenter ¶

func (r *RegisterRequest) RequestDatacenter() string

type ServerHealth ¶

ServerHealth is the health (from the leader's point of view) of a server.

type ServerHealth struct {
    // ID is the raft ID of the server.
    ID string

    // Name is the node name of the server.
    Name string

    // Address is the address of the server.
    Address string

    // The status of the SerfHealth check for the server.
    SerfStatus serf.MemberStatus

    // Version is the Consul version of the server.
    Version string

    // Leader is whether this server is currently the leader.
    Leader bool

    // LastContact is the time since this node's last contact with the leader.
    LastContact time.Duration

    // LastTerm is the highest leader term this server has a record of in its Raft log.
    LastTerm uint64

    // LastIndex is the last log index this server has a record of in its Raft log.
    LastIndex uint64

    // Healthy is whether or not the server is healthy according to the current
    // Autopilot config.
    Healthy bool

    // Voter is whether this is a voting server.
    Voter bool

    // StableSince is the last time this server's Healthy value changed.
    StableSince time.Time
}

func (*ServerHealth) IsHealthy ¶

func (h *ServerHealth) IsHealthy(lastTerm uint64, leaderLastIndex uint64, autopilotConf *AutopilotConfig) bool

IsHealthy determines whether this ServerHealth is considered healthy based on the given Autopilot config

func (*ServerHealth) IsStable ¶

func (h *ServerHealth) IsStable(now time.Time, conf *AutopilotConfig) bool

IsStable returns true if the ServerHealth is in a stable, passing state according to the given AutopilotConfig

type ServerStats ¶

ServerStats holds miscellaneous Raft metrics for a server

type ServerStats struct {
    // LastContact is the time since this node's last contact with the leader.
    LastContact string

    // LastTerm is the highest leader term this server has a record of in its Raft log.
    LastTerm uint64

    // LastIndex is the last log index this server has a record of in its Raft log.
    LastIndex uint64
}

type ServiceNode ¶

ServiceNode represents a node that is part of a service. ID, Address, TaggedAddresses, and NodeMeta are node-related fields that are always empty in the state store and are filled in on the way out by parseServiceNodes(). This is also why PartialClone() skips them, because we know they are blank already so it would be a waste of time to copy them.

type ServiceNode struct {
    ID                       types.NodeID
    Node                     string
    Address                  string
    Datacenter               string
    TaggedAddresses          map[string]string
    NodeMeta                 map[string]string
    ServiceID                string
    ServiceName              string
    ServiceTags              []string
    ServiceAddress           string
    ServicePort              int
    ServiceEnableTagOverride bool

    RaftIndex
}

func (*ServiceNode) PartialClone ¶

func (s *ServiceNode) PartialClone() *ServiceNode

PartialClone() returns a clone of the given service node, minus the node- related fields that get filled in later, Address and TaggedAddresses.

func (*ServiceNode) ToNodeService ¶

func (s *ServiceNode) ToNodeService() *NodeService

ToNodeService converts the given service node to a node service.

type ServiceNodes ¶

type ServiceNodes []*ServiceNode

type ServiceQuery ¶

ServiceQuery is used to query for a set of healthy nodes offering a specific service.

type ServiceQuery struct {
    // Service is the service to query.
    Service string

    // Failover controls what we do if there are no healthy nodes in the
    // local datacenter.
    Failover QueryDatacenterOptions

    // If OnlyPassing is true then we will only include nodes with passing
    // health checks (critical AND warning checks will cause a node to be
    // discarded)
    OnlyPassing bool

    // Near allows the query to always prefer the node nearest the given
    // node. If the node does not exist, results are returned in their
    // normal randomly-shuffled order. Supplying the magic "_agent" value
    // is supported to sort near the agent which initiated the request.
    Near string

    // Tags are a set of required and/or disallowed tags. If a tag is in
    // this list it must be present. If the tag is preceded with "!" then
    // it is disallowed.
    Tags []string

    // NodeMeta is a map of required node metadata fields. If a key/value
    // pair is in this map it must be present on the node in order for the
    // service entry to be returned.
    NodeMeta map[string]string
}

type ServiceSpecificRequest ¶

ServiceSpecificRequest is used to query about a specific service

type ServiceSpecificRequest struct {
    Datacenter      string
    NodeMetaFilters map[string]string
    ServiceName     string
    ServiceTag      string
    TagFilter       bool // Controls tag filtering
    Source          QuerySource
    QueryOptions
}

func (*ServiceSpecificRequest) RequestDatacenter ¶

func (r *ServiceSpecificRequest) RequestDatacenter() string

type Services ¶

Used to return information about a provided services. Maps service name to available tags

type Services map[string][]string

type Session ¶

Session is used to represent an open session in the KV store. This issued to associate node checks with acquired locks.

type Session struct {
    ID        string
    Name      string
    Node      string
    Checks    []types.CheckID
    LockDelay time.Duration
    Behavior  SessionBehavior // What to do when session is invalidated
    TTL       string

    RaftIndex
}

type SessionBehavior ¶

type SessionBehavior string

const (
    SessionKeysRelease SessionBehavior = "release"
    SessionKeysDelete                  = "delete"
)

type SessionOp ¶

type SessionOp string

const (
    SessionCreate  SessionOp = "create"
    SessionDestroy           = "destroy"
)

type SessionRequest ¶

SessionRequest is used to operate on sessions

type SessionRequest struct {
    Datacenter string
    Op         SessionOp // Which operation are we performing
    Session    Session   // Which session
    WriteRequest
}

func (*SessionRequest) RequestDatacenter ¶

func (r *SessionRequest) RequestDatacenter() string

type SessionSpecificRequest ¶

SessionSpecificRequest is used to request a session by ID

type SessionSpecificRequest struct {
    Datacenter string
    Session    string
    QueryOptions
}

func (*SessionSpecificRequest) RequestDatacenter ¶

func (r *SessionSpecificRequest) RequestDatacenter() string

type Sessions ¶

type Sessions []*Session

type SnapshotOp ¶

type SnapshotOp int

const (
    SnapshotSave SnapshotOp = iota
    SnapshotRestore
)

type SnapshotRequest ¶

SnapshotRequest is used as a header for a snapshot RPC request. This will precede any streaming data that's part of the request and is JSON-encoded on the wire.

type SnapshotRequest struct {
    // Datacenter is the target datacenter for this request. The request
    // will be forwarded if necessary.
    Datacenter string

    // Token is the ACL token to use for the operation. If ACLs are enabled
    // then all operations require a management token.
    Token string

    // If set, any follower can service the request. Results may be
    // arbitrarily stale. Only applies to SnapshotSave.
    AllowStale bool

    // Op is the operation code for the RPC.
    Op SnapshotOp
}

type SnapshotResponse ¶

SnapshotResponse is used header for a snapshot RPC response. This will precede any streaming data that's part of the request and is JSON-encoded on the wire.

type SnapshotResponse struct {
    // Error is the overall error status of the RPC request.
    Error string

    // QueryMeta has freshness information about the server that handled the
    // request. It is only filled in for a SnapshotSave.
    QueryMeta
}

type TombstoneOp ¶

type TombstoneOp string

const (
    TombstoneReap TombstoneOp = "reap"
)

type TombstoneRequest ¶

TombstoneRequest is used to trigger a reaping of the tombstones

type TombstoneRequest struct {
    Datacenter string
    Op         TombstoneOp
    ReapIndex  uint64
    WriteRequest
}

func (*TombstoneRequest) RequestDatacenter ¶

func (r *TombstoneRequest) RequestDatacenter() string

type TxnError ¶

TxnError is used to return information about an error for a specific operation.

type TxnError struct {
    OpIndex int
    What    string
}

func (TxnError) Error ¶

func (e TxnError) Error() string

Error returns the string representation of an atomic error.

type TxnErrors ¶

TxnErrors is a list of TxnError entries.

type TxnErrors []*TxnError

type TxnKVOp ¶

TxnKVOp is used to define a single operation on the KVS inside a transaction

type TxnKVOp struct {
    Verb   api.KVOp
    DirEnt DirEntry
}

type TxnKVResult ¶

TxnKVResult is used to define the result of a single operation on the KVS inside a transaction.

type TxnKVResult *DirEntry

type TxnOp ¶

TxnOp is used to define a single operation inside a transaction. Only one of the types should be filled out per entry.

type TxnOp struct {
    KV *TxnKVOp
}

type TxnOps ¶

TxnOps is a list of operations within a transaction.

type TxnOps []*TxnOp

type TxnReadRequest ¶

TxnReadRequest is used as a fast path for read-only transactions that don't modify the state store.

type TxnReadRequest struct {
    Datacenter string
    Ops        TxnOps
    QueryOptions
}

func (*TxnReadRequest) RequestDatacenter ¶

func (r *TxnReadRequest) RequestDatacenter() string

type TxnReadResponse ¶

TxnReadResponse is the structure returned by a TxnReadRequest.

type TxnReadResponse struct {
    TxnResponse
    QueryMeta
}

type TxnRequest ¶

TxnRequest is used to apply multiple operations to the state store in a single transaction

type TxnRequest struct {
    Datacenter string
    Ops        TxnOps
    WriteRequest
}

func (*TxnRequest) RequestDatacenter ¶

func (r *TxnRequest) RequestDatacenter() string

type TxnResponse ¶

TxnResponse is the structure returned by a TxnRequest.

type TxnResponse struct {
    Results TxnResults
    Errors  TxnErrors
}

type TxnResult ¶

TxnResult is used to define the result of a given operation inside a transaction. Only one of the types should be filled out per entry.

type TxnResult struct {
    KV TxnKVResult
}

type TxnResults ¶

TxnResults is a list of TxnResult entries.

type TxnResults []*TxnResult

type WriteRequest ¶

type WriteRequest struct {
    // Token is the ACL token ID. If not provided, the 'anonymous'
    // token is assumed for backwards compatibility.
    Token string
}

func (WriteRequest) ACLToken ¶

func (w WriteRequest) ACLToken() string

func (WriteRequest) AllowStaleRead ¶

func (w WriteRequest) AllowStaleRead() bool

func (WriteRequest) IsRead ¶

func (w WriteRequest) IsRead() bool

WriteRequest only applies to writes, always false