lxd: github.com/lxc/lxd/lxd/db/cluster Index | Files

package cluster

import "github.com/lxc/lxd/lxd/db/cluster"

Index

Package Files

constants.go open.go query.go schema.go stmt.go update.go

Constants

const (
    TypeContainer = iota
    TypeImage
    TypeProfile
    TypeProject
)

Numeric type codes identifying different kind of entities.

Variables

var EntityFormatURIs = map[int]func(a ...interface{}) string{
    TypeContainer: func(a ...interface{}) string {
        uri := fmt.Sprintf(EntityURIs[TypeContainer], a[1], a[0])
        if a[0] == "default" {
            return strings.Split(uri, fmt.Sprintf("?project=%s", a[0]))[0]
        }

        return uri
    },
    TypeProfile: func(a ...interface{}) string {
        uri := fmt.Sprintf(EntityURIs[TypeProfile], a[1], a[0])
        if a[0] == "default" {
            return strings.Split(uri, fmt.Sprintf("?project=%s", a[0]))[0]
        }

        return uri
    },
    TypeProject: func(a ...interface{}) string {
        uri := fmt.Sprintf(EntityURIs[TypeProject], a[0])
        return uri
    },
}

EntityFormatURIs associates an entity code to a formatter function that can be used to format its URI.

var EntityNames = map[int]string{
    TypeContainer: "container",
    TypeImage:     "image",
    TypeProfile:   "profile",
    TypeProject:   "project",
}

EntityNames associates an entity code to its name.

var EntityTypes = map[string]int{}

EntityTypes associates an entity name to its type code.

var EntityURIs = map[int]string{
    TypeContainer: "/" + version.APIVersion + "/containers/%s?project=%s",
    TypeImage:     "/" + version.APIVersion + "/images/%s",
    TypeProfile:   "/" + version.APIVersion + "/profiles/%s?project=%s",
    TypeProject:   "/" + version.APIVersion + "/projects/%s",
}

EntityURIs associates an entity code to its URI pattern.

var SchemaVersion = len(updates)

SchemaVersion is the current version of the cluster database schema.

func EnsureSchema Uses

func EnsureSchema(db *sql.DB, address string, dir string) (bool, error)

EnsureSchema applies all relevant schema updates to the cluster database.

Before actually doing anything, this function will make sure that all nodes in the cluster have a schema version and a number of API extensions that match our one. If it's not the case, we either return an error (if some nodes have version greater than us and we need to be upgraded), or return false and no error (if some nodes have a lower version, and we need to wait till they get upgraded and restarted).

func FreshSchema Uses

func FreshSchema() string

FreshSchema returns the fresh schema definition of the global database.

func Open Uses

func Open(name string, store driver.NodeStore, options ...driver.Option) (*sql.DB, error)

Open the cluster database object.

The name argument is the name of the cluster database. It defaults to 'db.bin', but can be overwritten for testing.

The dialer argument is a function that returns a gRPC dialer that can be used to connect to a database node using the gRPC SQL package.

func PrepareStmts Uses

func PrepareStmts(db *sql.DB) (map[int]*sql.Stmt, error)

PrepareStmts prepares all registered statements and returns an index from statement code to prepared statement object.

func RegisterStmt Uses

func RegisterStmt(sql string) int

RegisterStmt register a SQL statement.

Registered statements will be prepared upfront and re-used, to speed up execution.

Return a unique registration code.

func Schema Uses

func Schema() *schema.Schema

Schema for the cluster database.

func SchemaDotGo Uses

func SchemaDotGo() error

SchemaDotGo refreshes the schema.go file in this package, using the updates defined here.

Package cluster imports 15 packages (graph) and is imported by 22 packages. Updated 2019-09-29. Refresh now. Tools for package owners.