_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q176700 | Authenticate | test | func (d *Daemon) Authenticate(r *http.Request) (bool, string, string, error) {
// Allow internal cluster traffic
if r.TLS != nil {
cert, _ := x509.ParseCertificate(d.endpoints.NetworkCert().KeyPair().Certificate[0])
clusterCerts := map[string]x509.Certificate{"0": *cert}
for i := range r.TLS.PeerCertificates {
... | go | {
"resource": ""
} |
q176701 | State | test | func (d *Daemon) State() *state.State {
return state.NewState(d.db, d.cluster, d.maas, d.os, d.endpoints)
} | go | {
"resource": ""
} |
q176702 | UnixSocket | test | func (d *Daemon) UnixSocket() string {
path := os.Getenv("LXD_SOCKET")
if path != "" {
return path
}
return filepath.Join(d.os.VarDir, "unix.socket")
} | go | {
"resource": ""
} |
q176703 | Stop | test | func (d *Daemon) Stop() error {
logger.Info("Starting shutdown sequence")
errs := []error{}
trackError := func(err error) {
if err != nil {
errs = append(errs, err)
}
}
if d.endpoints != nil {
trackError(d.endpoints.Down())
}
trackError(d.tasks.Stop(3 * time.Second)) // Give tasks a bit of time... | go | {
"resource": ""
} |
q176704 | setupExternalAuthentication | test | func (d *Daemon) setupExternalAuthentication(authEndpoint string, authPubkey string, expiry int64, domains string) error {
// Parse the list of domains
authDomains := []string{}
for _, domain := range strings.Split(domains, ",") {
if domain == "" {
continue
}
authDomains = append(authDomains, strings.TrimS... | go | {
"resource": ""
} |
q176705 | initializeDbObject | test | func initializeDbObject(d *Daemon) (*db.Dump, error) {
logger.Info("Initializing local database")
// Rename the old database name if needed.
if shared.PathExists(d.os.LegacyLocalDatabasePath()) {
if shared.PathExists(d.os.LocalDatabasePath()) {
return nil, fmt.Errorf("Both legacy and new local database files ex... | go | {
"resource": ""
} |
q176706 | WriteJSON | test | func WriteJSON(w http.ResponseWriter, body interface{}, debug bool) error {
var output io.Writer
var captured *bytes.Buffer
output = w
if debug {
captured = &bytes.Buffer{}
output = io.MultiWriter(w, captured)
}
err := json.NewEncoder(output).Encode(body)
if captured != nil {
shared.DebugJson(captured)
... | go | {
"resource": ""
} |
q176707 | EtagHash | test | func EtagHash(data interface{}) (string, error) {
etag := sha256.New()
err := json.NewEncoder(etag).Encode(data)
if err != nil {
return "", err
}
return fmt.Sprintf("%x", etag.Sum(nil)), nil
} | go | {
"resource": ""
} |
q176708 | EtagCheck | test | func EtagCheck(r *http.Request, data interface{}) error {
match := r.Header.Get("If-Match")
if match == "" {
return nil
}
hash, err := EtagHash(data)
if err != nil {
return err
}
if hash != match {
return fmt.Errorf("ETag doesn't match: %s vs %s", hash, match)
}
return nil
} | go | {
"resource": ""
} |
q176709 | HTTPClient | test | func HTTPClient(certificate string, proxy proxyFunc) (*http.Client, error) {
var err error
var cert *x509.Certificate
if certificate != "" {
certBlock, _ := pem.Decode([]byte(certificate))
if certBlock == nil {
return nil, fmt.Errorf("Invalid certificate")
}
cert, err = x509.ParseCertificate(certBlock.B... | go | {
"resource": ""
} |
q176710 | IsRecursionRequest | test | func IsRecursionRequest(r *http.Request) bool {
recursionStr := r.FormValue("recursion")
recursion, err := strconv.Atoi(recursionStr)
if err != nil {
return false
}
return recursion != 0
} | go | {
"resource": ""
} |
q176711 | GetListeners | test | func GetListeners(start int) []net.Listener {
defer func() {
os.Unsetenv("LISTEN_PID")
os.Unsetenv("LISTEN_FDS")
}()
pid, err := strconv.Atoi(os.Getenv("LISTEN_PID"))
if err != nil {
return nil
}
if pid != os.Getpid() {
return nil
}
fds, err := strconv.Atoi(os.Getenv("LISTEN_FDS"))
if err != nil {
... | go | {
"resource": ""
} |
q176712 | internalSQLGet | test | func internalSQLGet(d *Daemon, r *http.Request) Response {
database := r.FormValue("database")
if !shared.StringInSlice(database, []string{"local", "global"}) {
return BadRequest(fmt.Errorf("Invalid database"))
}
schemaFormValue := r.FormValue("schema")
schemaOnly, err := strconv.Atoi(schemaFormValue)
if err ... | go | {
"resource": ""
} |
q176713 | internalSQLPost | test | func internalSQLPost(d *Daemon, r *http.Request) Response {
req := &internalSQLQuery{}
// Parse the request.
err := json.NewDecoder(r.Body).Decode(&req)
if err != nil {
return BadRequest(err)
}
if !shared.StringInSlice(req.Database, []string{"local", "global"}) {
return BadRequest(fmt.Errorf("Invalid databas... | go | {
"resource": ""
} |
q176714 | PublicKey | test | func (c *CertInfo) PublicKey() []byte {
data := c.KeyPair().Certificate[0]
return pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: data})
} | go | {
"resource": ""
} |
q176715 | PrivateKey | test | func (c *CertInfo) PrivateKey() []byte {
ecKey, ok := c.KeyPair().PrivateKey.(*ecdsa.PrivateKey)
if ok {
data, err := x509.MarshalECPrivateKey(ecKey)
if err != nil {
return nil
}
return pem.EncodeToMemory(&pem.Block{Type: "EC PRIVATE KEY", Bytes: data})
}
rsaKey, ok := c.KeyPair().PrivateKey.(*rsa.Priv... | go | {
"resource": ""
} |
q176716 | Fingerprint | test | func (c *CertInfo) Fingerprint() string {
fingerprint, err := CertFingerprintStr(string(c.PublicKey()))
// Parsing should never fail, since we generated the cert ourselves,
// but let's check the error for good measure.
if err != nil {
panic("invalid public key material")
}
return fingerprint
} | go | {
"resource": ""
} |
q176717 | GenCert | test | func GenCert(certf string, keyf string, certtype bool) error {
/* Create the basenames if needed */
dir := path.Dir(certf)
err := os.MkdirAll(dir, 0750)
if err != nil {
return err
}
dir = path.Dir(keyf)
err = os.MkdirAll(dir, 0750)
if err != nil {
return err
}
certBytes, keyBytes, err := GenerateMemCert(... | go | {
"resource": ""
} |
q176718 | PrintServerInfo | test | func PrintServerInfo(c lxd.ContainerServer) error {
server, _, err := c.GetServer()
if err != nil {
return err
}
env := server.Environment
fmt.Printf("Test environment:\n")
fmt.Printf(" Server backend: %s\n", env.Server)
fmt.Printf(" Server version: %s\n", env.ServerVersion)
fmt.Printf(" Kernel: %s\n", env... | go | {
"resource": ""
} |
q176719 | LaunchContainers | test | func LaunchContainers(c lxd.ContainerServer, count int, parallel int, image string, privileged bool, start bool, freeze bool) (time.Duration, error) {
var duration time.Duration
batchSize, err := getBatchSize(parallel)
if err != nil {
return duration, err
}
printTestConfig(count, batchSize, image, privileged, ... | go | {
"resource": ""
} |
q176720 | CreateContainers | test | func CreateContainers(c lxd.ContainerServer, count int, parallel int, fingerprint string, privileged bool) (time.Duration, error) {
var duration time.Duration
batchSize, err := getBatchSize(parallel)
if err != nil {
return duration, err
}
batchCreate := func(index int, wg *sync.WaitGroup) {
defer wg.Done()
... | go | {
"resource": ""
} |
q176721 | GetContainers | test | func GetContainers(c lxd.ContainerServer) ([]api.Container, error) {
containers := []api.Container{}
allContainers, err := c.GetContainers()
if err != nil {
return containers, err
}
for _, container := range allContainers {
if container.Config[userConfigKey] == "true" {
containers = append(containers, con... | go | {
"resource": ""
} |
q176722 | StartContainers | test | func StartContainers(c lxd.ContainerServer, containers []api.Container, parallel int) (time.Duration, error) {
var duration time.Duration
batchSize, err := getBatchSize(parallel)
if err != nil {
return duration, err
}
count := len(containers)
logf("Starting %d containers", count)
batchStart := func(index in... | go | {
"resource": ""
} |
q176723 | setQueryParam | test | func setQueryParam(uri, param, value string) (string, error) {
fields, err := url.Parse(uri)
if err != nil {
return "", err
}
values := fields.Query()
values.Set(param, url.QueryEscape(value))
fields.RawQuery = values.Encode()
return fields.String(), nil
} | go | {
"resource": ""
} |
q176724 | GetImages | test | func (r *ProtocolLXD) GetImages() ([]api.Image, error) {
images := []api.Image{}
_, err := r.queryStruct("GET", "/images?recursion=1", nil, "", &images)
if err != nil {
return nil, err
}
return images, nil
} | go | {
"resource": ""
} |
q176725 | GetImageFile | test | func (r *ProtocolLXD) GetImageFile(fingerprint string, req ImageFileRequest) (*ImageFileResponse, error) {
return r.GetPrivateImageFile(fingerprint, "", req)
} | go | {
"resource": ""
} |
q176726 | GetImageSecret | test | func (r *ProtocolLXD) GetImageSecret(fingerprint string) (string, error) {
op, err := r.CreateImageSecret(fingerprint)
if err != nil {
return "", err
}
opAPI := op.Get()
return opAPI.Metadata["secret"].(string), nil
} | go | {
"resource": ""
} |
q176727 | GetPrivateImage | test | func (r *ProtocolLXD) GetPrivateImage(fingerprint string, secret string) (*api.Image, string, error) {
image := api.Image{}
// Build the API path
path := fmt.Sprintf("/images/%s", url.QueryEscape(fingerprint))
var err error
path, err = r.setQueryAttributes(path)
if err != nil {
return nil, "", err
}
if secr... | go | {
"resource": ""
} |
q176728 | GetPrivateImageFile | test | func (r *ProtocolLXD) GetPrivateImageFile(fingerprint string, secret string, req ImageFileRequest) (*ImageFileResponse, error) {
// Sanity checks
if req.MetaFile == nil && req.RootfsFile == nil {
return nil, fmt.Errorf("No file requested")
}
uri := fmt.Sprintf("/1.0/images/%s/export", url.QueryEscape(fingerprint... | go | {
"resource": ""
} |
q176729 | GetImageAliases | test | func (r *ProtocolLXD) GetImageAliases() ([]api.ImageAliasesEntry, error) {
aliases := []api.ImageAliasesEntry{}
// Fetch the raw value
_, err := r.queryStruct("GET", "/images/aliases?recursion=1", nil, "", &aliases)
if err != nil {
return nil, err
}
return aliases, nil
} | go | {
"resource": ""
} |
q176730 | tryCopyImage | test | func (r *ProtocolLXD) tryCopyImage(req api.ImagesPost, urls []string) (RemoteOperation, error) {
if len(urls) == 0 {
return nil, fmt.Errorf("The source server isn't listening on the network")
}
rop := remoteOperation{
chDone: make(chan bool),
}
// For older servers, apply the aliases after copy
if !r.HasExt... | go | {
"resource": ""
} |
q176731 | CopyImage | test | func (r *ProtocolLXD) CopyImage(source ImageServer, image api.Image, args *ImageCopyArgs) (RemoteOperation, error) {
// Sanity checks
if r == source {
return nil, fmt.Errorf("The source and target servers must be different")
}
// Get source server connection information
info, err := source.GetConnectionInfo()
... | go | {
"resource": ""
} |
q176732 | UpdateImage | test | func (r *ProtocolLXD) UpdateImage(fingerprint string, image api.ImagePut, ETag string) error {
// Send the request
_, _, err := r.query("PUT", fmt.Sprintf("/images/%s", url.QueryEscape(fingerprint)), image, ETag)
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q176733 | DeleteImage | test | func (r *ProtocolLXD) DeleteImage(fingerprint string) (Operation, error) {
// Send the request
op, _, err := r.queryOperation("DELETE", fmt.Sprintf("/images/%s", url.QueryEscape(fingerprint)), nil, "")
if err != nil {
return nil, err
}
return op, nil
} | go | {
"resource": ""
} |
q176734 | RefreshImage | test | func (r *ProtocolLXD) RefreshImage(fingerprint string) (Operation, error) {
if !r.HasExtension("image_force_refresh") {
return nil, fmt.Errorf("The server is missing the required \"image_force_refresh\" API extension")
}
// Send the request
op, _, err := r.queryOperation("POST", fmt.Sprintf("/images/%s/refresh",... | go | {
"resource": ""
} |
q176735 | CreateImageAlias | test | func (r *ProtocolLXD) CreateImageAlias(alias api.ImageAliasesPost) error {
// Send the request
_, _, err := r.query("POST", "/images/aliases", alias, "")
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q176736 | UpdateImageAlias | test | func (r *ProtocolLXD) UpdateImageAlias(name string, alias api.ImageAliasesEntryPut, ETag string) error {
// Send the request
_, _, err := r.query("PUT", fmt.Sprintf("/images/aliases/%s", url.QueryEscape(name)), alias, ETag)
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q176737 | RenameImageAlias | test | func (r *ProtocolLXD) RenameImageAlias(name string, alias api.ImageAliasesEntryPost) error {
// Send the request
_, _, err := r.query("POST", fmt.Sprintf("/images/aliases/%s", url.QueryEscape(name)), alias, "")
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q176738 | DeleteImageAlias | test | func (r *ProtocolLXD) DeleteImageAlias(name string) error {
// Send the request
_, _, err := r.query("DELETE", fmt.Sprintf("/images/aliases/%s", url.QueryEscape(name)), nil, "")
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q176739 | Open | test | func Open(dir string) (*sql.DB, error) {
path := filepath.Join(dir, "local.db")
db, err := sqliteOpen(path)
if err != nil {
return nil, fmt.Errorf("cannot open node database: %v", err)
}
return db, nil
} | go | {
"resource": ""
} |
q176740 | EnsureSchema | test | func EnsureSchema(db *sql.DB, dir string, hook schema.Hook) (int, error) {
backupDone := false
schema := Schema()
schema.File(filepath.Join(dir, "patch.local.sql")) // Optional custom queries
schema.Hook(func(version int, tx *sql.Tx) error {
if !backupDone {
logger.Infof("Updating the LXD database schema. Bac... | go | {
"resource": ""
} |
q176741 | FilesystemDetect | test | func FilesystemDetect(path string) (string, error) {
fs := syscall.Statfs_t{}
err := syscall.Statfs(path, &fs)
if err != nil {
return "", err
}
switch fs.Type {
case FilesystemSuperMagicBtrfs:
return "btrfs", nil
case FilesystemSuperMagicZfs:
return "zfs", nil
case FilesystemSuperMagicTmpfs:
return "t... | go | {
"resource": ""
} |
q176742 | Schema | test | func Schema() *schema.Schema {
schema := schema.NewFromMap(updates)
schema.Fresh(freshSchema)
return schema
} | go | {
"resource": ""
} |
q176743 | updateFromV37 | test | func updateFromV37(tx *sql.Tx) error {
count, err := query.Count(tx, "raft_nodes", "")
if err != nil {
return errors.Wrap(err, "Fetch count of Raft nodes")
}
if count == 0 {
// This node is not clustered, nothing to do.
return nil
}
// Copy the core.https_address config.
_, err = tx.Exec(`
INSERT INTO co... | go | {
"resource": ""
} |
q176744 | ArchitectureGetLocal | test | func ArchitectureGetLocal() (string, error) {
uname, err := shared.Uname()
if err != nil {
return ArchitectureDefault, err
}
return uname.Machine, nil
} | go | {
"resource": ""
} |
q176745 | NewController | test | func NewController(url string, key string, machine string) (*Controller, error) {
baseURL := fmt.Sprintf("%s/api/2.0/", url)
// Connect to MAAS
srv, err := gomaasapi.NewController(gomaasapi.ControllerArgs{
BaseURL: baseURL,
APIKey: key,
})
if err != nil {
// Juju errors aren't user-friendly, try to extract... | go | {
"resource": ""
} |
q176746 | CreateContainer | test | func (c *Controller) CreateContainer(name string, interfaces []ContainerInterface) error {
// Parse the provided interfaces
macInterfaces, err := parseInterfaces(interfaces)
if err != nil {
return err
}
// Get all the subnets
subnets, err := c.getSubnets()
if err != nil {
return err
}
// Create the devic... | go | {
"resource": ""
} |
q176747 | DefinedContainer | test | func (c *Controller) DefinedContainer(name string) (bool, error) {
devs, err := c.machine.Devices(gomaasapi.DevicesArgs{Hostname: []string{name}})
if err != nil {
return false, err
}
if len(devs) == 1 {
return true, nil
}
return false, nil
} | go | {
"resource": ""
} |
q176748 | UpdateContainer | test | func (c *Controller) UpdateContainer(name string, interfaces []ContainerInterface) error {
// Parse the provided interfaces
macInterfaces, err := parseInterfaces(interfaces)
if err != nil {
return err
}
// Get all the subnets
subnets, err := c.getSubnets()
if err != nil {
return err
}
device, err := c.ge... | go | {
"resource": ""
} |
q176749 | RenameContainer | test | func (c *Controller) RenameContainer(name string, newName string) error {
device, err := c.getDevice(name)
if err != nil {
return err
}
// FIXME: We should convince the Juju folks to implement an Update() method on Device
uri, err := url.Parse(fmt.Sprintf("%s/devices/%s/", c.url, device.SystemID()))
if err != ... | go | {
"resource": ""
} |
q176750 | DeleteContainer | test | func (c *Controller) DeleteContainer(name string) error {
device, err := c.getDevice(name)
if err != nil {
return err
}
err = device.Delete()
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q176751 | Add | test | func (s *Schema) Add(update Update) {
s.updates = append(s.updates, update)
} | go | {
"resource": ""
} |
q176752 | ensureSchemaTableExists | test | func ensureSchemaTableExists(tx *sql.Tx) error {
exists, err := DoesSchemaTableExist(tx)
if err != nil {
return fmt.Errorf("failed to check if schema table is there: %v", err)
}
if !exists {
err := createSchemaTable(tx)
if err != nil {
return fmt.Errorf("failed to create schema table: %v", err)
}
}
ret... | go | {
"resource": ""
} |
q176753 | queryCurrentVersion | test | func queryCurrentVersion(tx *sql.Tx) (int, error) {
versions, err := selectSchemaVersions(tx)
if err != nil {
return -1, fmt.Errorf("failed to fetch update versions: %v", err)
}
// Fix bad upgrade code between 30 and 32
hasVersion := func(v int) bool { return shared.IntInSlice(v, versions) }
if hasVersion(30) ... | go | {
"resource": ""
} |
q176754 | ensureUpdatesAreApplied | test | func ensureUpdatesAreApplied(tx *sql.Tx, current int, updates []Update, hook Hook) error {
if current > len(updates) {
return fmt.Errorf(
"schema version '%d' is more recent than expected '%d'",
current, len(updates))
}
// If there are no updates, there's nothing to do.
if len(updates) == 0 {
return nil
... | go | {
"resource": ""
} |
q176755 | checkSchemaVersionsHaveNoHoles | test | func checkSchemaVersionsHaveNoHoles(versions []int) error {
// Sanity check that there are no "holes" in the recorded
// versions.
for i := range versions[:len(versions)-1] {
if versions[i+1] != versions[i]+1 {
return fmt.Errorf("Missing updates: %d to %d", versions[i], versions[i+1])
}
}
return nil
} | go | {
"resource": ""
} |
q176756 | checkAllUpdatesAreApplied | test | func checkAllUpdatesAreApplied(tx *sql.Tx, updates []Update) error {
versions, err := selectSchemaVersions(tx)
if err != nil {
return fmt.Errorf("failed to fetch update versions: %v", err)
}
if len(versions) == 0 {
return fmt.Errorf("expected schema table to contain at least one row")
}
err = checkSchemaVer... | go | {
"resource": ""
} |
q176757 | formatSQL | test | func formatSQL(statement string) string {
lines := strings.Split(statement, "\n")
for i, line := range lines {
if strings.Contains(line, "UNIQUE") {
// Let UNIQUE(x, y) constraints alone.
continue
}
lines[i] = strings.Replace(line, ", ", ",\n ", -1)
}
return strings.Join(lines, "\n")
} | go | {
"resource": ""
} |
q176758 | GetAllXattr | test | func GetAllXattr(path string) (xattrs map[string]string, err error) {
e1 := fmt.Errorf("Extended attributes changed during retrieval")
// Call llistxattr() twice: First, to determine the size of the buffer
// we need to allocate to store the extended attributes, second, to
// actually store the extended attributes... | go | {
"resource": ""
} |
q176759 | GetErrno | test | func GetErrno(err error) (errno error, iserrno bool) {
sysErr, ok := err.(*os.SyscallError)
if ok {
return sysErr.Err, true
}
pathErr, ok := err.(*os.PathError)
if ok {
return pathErr.Err, true
}
tmpErrno, ok := err.(syscall.Errno)
if ok {
return tmpErrno, true
}
return nil, false
} | go | {
"resource": ""
} |
q176760 | Uname | test | func Uname() (*Utsname, error) {
/*
* Based on: https://groups.google.com/forum/#!topic/golang-nuts/Jel8Bb-YwX8
* there is really no better way to do this, which is
* unfortunate. Also, we ditch the more accepted CharsToString
* version in that thread, since it doesn't seem as portable,
* viz. github issue #... | go | {
"resource": ""
} |
q176761 | RegisterStmt | test | func RegisterStmt(sql string) int {
code := len(stmts)
stmts[code] = sql
return code
} | go | {
"resource": ""
} |
q176762 | PrepareStmts | test | func PrepareStmts(db *sql.DB) (map[int]*sql.Stmt, error) {
index := map[int]*sql.Stmt{}
for code, sql := range stmts {
stmt, err := db.Prepare(sql)
if err != nil {
return nil, errors.Wrapf(err, "%q", sql)
}
index[code] = stmt
}
return index, nil
} | go | {
"resource": ""
} |
q176763 | NewGateway | test | func NewGateway(db *db.Node, cert *shared.CertInfo, options ...Option) (*Gateway, error) {
ctx, cancel := context.WithCancel(context.Background())
o := newOptions()
for _, option := range options {
option(o)
}
gateway := &Gateway{
db: db,
cert: cert,
options: o,
ctx: ctx,
cancel:... | go | {
"resource": ""
} |
q176764 | DialFunc | test | func (g *Gateway) DialFunc() dqlite.DialFunc {
return func(ctx context.Context, address string) (net.Conn, error) {
// Memory connection.
if g.memoryDial != nil {
return g.memoryDial(ctx, address)
}
return dqliteNetworkDial(ctx, address, g.cert)
}
} | go | {
"resource": ""
} |
q176765 | Shutdown | test | func (g *Gateway) Shutdown() error {
logger.Debugf("Stop database gateway")
if g.raft != nil {
err := g.raft.Shutdown()
if err != nil {
return errors.Wrap(err, "Failed to shutdown raft")
}
}
if g.server != nil {
g.Sync()
g.server.Close()
// Unset the memory dial, since Shutdown() is also called fo... | go | {
"resource": ""
} |
q176766 | Sync | test | func (g *Gateway) Sync() {
if g.server == nil {
return
}
dir := filepath.Join(g.db.Dir(), "global")
err := g.server.Dump("db.bin", dir)
if err != nil {
// Just log a warning, since this is not fatal.
logger.Warnf("Failed to dump database to disk: %v", err)
}
} | go | {
"resource": ""
} |
q176767 | Reset | test | func (g *Gateway) Reset(cert *shared.CertInfo) error {
err := g.Shutdown()
if err != nil {
return err
}
err = os.RemoveAll(filepath.Join(g.db.Dir(), "global"))
if err != nil {
return err
}
err = g.db.Transaction(func(tx *db.NodeTx) error {
return tx.RaftNodesReplace(nil)
})
if err != nil {
return err
... | go | {
"resource": ""
} |
q176768 | LeaderAddress | test | func (g *Gateway) LeaderAddress() (string, error) {
// If we aren't clustered, return an error.
if g.memoryDial != nil {
return "", fmt.Errorf("Node is not clustered")
}
ctx, cancel := context.WithTimeout(g.ctx, 5*time.Second)
defer cancel()
// If this is a raft node, return the address of the current leader,... | go | {
"resource": ""
} |
q176769 | waitLeadership | test | func (g *Gateway) waitLeadership() error {
n := 80
sleep := 250 * time.Millisecond
for i := 0; i < n; i++ {
if g.raft.raft.State() == raft.Leader {
return nil
}
time.Sleep(sleep)
}
return fmt.Errorf("RAFT node did not self-elect within %s", time.Duration(n)*sleep)
} | go | {
"resource": ""
} |
q176770 | currentRaftNodes | test | func (g *Gateway) currentRaftNodes() ([]db.RaftNode, error) {
if g.raft == nil {
return nil, raft.ErrNotLeader
}
servers, err := g.raft.Servers()
if err != nil {
return nil, err
}
provider := raftAddressProvider{db: g.db}
nodes := make([]db.RaftNode, len(servers))
for i, server := range servers {
address,... | go | {
"resource": ""
} |
q176771 | cachedRaftNodes | test | func (g *Gateway) cachedRaftNodes() ([]string, error) {
var addresses []string
err := g.db.Transaction(func(tx *db.NodeTx) error {
var err error
addresses, err = tx.RaftNodeAddresses()
return err
})
if err != nil {
return nil, errors.Wrap(err, "Failed to fetch raft nodes")
}
return addresses, nil
} | go | {
"resource": ""
} |
q176772 | dqliteMemoryDial | test | func dqliteMemoryDial(listener net.Listener) dqlite.DialFunc {
return func(ctx context.Context, address string) (net.Conn, error) {
return net.Dial("unix", listener.Addr().String())
}
} | go | {
"resource": ""
} |
q176773 | DqliteLog | test | func DqliteLog(l dqlite.LogLevel, format string, a ...interface{}) {
format = fmt.Sprintf("Dqlite: %s", format)
switch l {
case dqlite.LogDebug:
logger.Debugf(format, a...)
case dqlite.LogInfo:
logger.Debugf(format, a...)
case dqlite.LogWarn:
logger.Warnf(format, a...)
case dqlite.LogError:
logger.Errorf(... | go | {
"resource": ""
} |
q176774 | MetadataAsMap | test | func (r *Response) MetadataAsMap() (map[string]interface{}, error) {
ret := map[string]interface{}{}
err := r.MetadataAsStruct(&ret)
if err != nil {
return nil, err
}
return ret, nil
} | go | {
"resource": ""
} |
q176775 | MetadataAsOperation | test | func (r *Response) MetadataAsOperation() (*Operation, error) {
op := Operation{}
err := r.MetadataAsStruct(&op)
if err != nil {
return nil, err
}
return &op, nil
} | go | {
"resource": ""
} |
q176776 | MetadataAsStringSlice | test | func (r *Response) MetadataAsStringSlice() ([]string, error) {
sl := []string{}
err := r.MetadataAsStruct(&sl)
if err != nil {
return nil, err
}
return sl, nil
} | go | {
"resource": ""
} |
q176777 | MetadataAsStruct | test | func (r *Response) MetadataAsStruct(target interface{}) error {
return json.Unmarshal(r.Metadata, &target)
} | go | {
"resource": ""
} |
q176778 | Load | test | func (r *CSVReport) Load() error {
file, err := os.Open(r.Filename)
if err != nil {
return err
}
defer file.Close()
reader := csv.NewReader(file)
for line := 1; err != io.EOF; line++ {
record, err := reader.Read()
if err == io.EOF {
break
} else if err != nil {
return err
}
err = r.addRecord(r... | go | {
"resource": ""
} |
q176779 | Write | test | func (r *CSVReport) Write() error {
file, err := os.OpenFile(r.Filename, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0640)
if err != nil {
return err
}
defer file.Close()
writer := csv.NewWriter(file)
err = writer.WriteAll(r.records)
if err != nil {
return err
}
logf("Written report file %s", r.Filename)
return... | go | {
"resource": ""
} |
q176780 | AddRecord | test | func (r *CSVReport) AddRecord(label string, elapsed time.Duration) error {
if len(r.records) == 0 {
r.addRecord(csvFields)
}
record := []string{
fmt.Sprintf("%d", time.Now().UnixNano()/int64(time.Millisecond)), // timestamp
fmt.Sprintf("%d", elapsed/time.Millisecond),
label,
"", // responseCode is not... | go | {
"resource": ""
} |
q176781 | LoadConfig | test | func LoadConfig(path string) (*Config, error) {
// Open the config file
content, err := ioutil.ReadFile(path)
if err != nil {
return nil, fmt.Errorf("Unable to read the configuration file: %v", err)
}
// Decode the yaml document
c := NewConfig(filepath.Dir(path), false)
err = yaml.Unmarshal(content, &c)
if e... | go | {
"resource": ""
} |
q176782 | SaveConfig | test | func (c *Config) SaveConfig(path string) error {
// Create a new copy for the config file
conf := Config{}
err := shared.DeepCopy(c, &conf)
if err != nil {
return fmt.Errorf("Unable to copy the configuration: %v", err)
}
// Remove the static remotes
for k := range StaticRemotes {
if k == "local" {
contin... | go | {
"resource": ""
} |
q176783 | Get | test | func (l ChrootLoader) Get(path string) (io.Reader, error) {
// Get the full path
path, err := filepath.EvalSymlinks(path)
if err != nil {
return nil, err
}
basePath, err := filepath.EvalSymlinks(l.Path)
if err != nil {
return nil, err
}
// Validate that we're under the expected prefix
if !strings.HasPref... | go | {
"resource": ""
} |
q176784 | ConfigPath | test | func (c *Config) ConfigPath(paths ...string) string {
path := []string{c.ConfigDir}
path = append(path, paths...)
return filepath.Join(path...)
} | go | {
"resource": ""
} |
q176785 | ServerCertPath | test | func (c *Config) ServerCertPath(remote string) string {
return c.ConfigPath("servercerts", fmt.Sprintf("%s.crt", remote))
} | go | {
"resource": ""
} |
q176786 | NewConfig | test | func NewConfig(configDir string, defaults bool) *Config {
config := &Config{ConfigDir: configDir}
if defaults {
config.Remotes = DefaultRemotes
config.DefaultRemote = "local"
}
return config
} | go | {
"resource": ""
} |
q176787 | checkForPreDumpSupport | test | func (s *migrationSourceWs) checkForPreDumpSupport() (bool, int) {
// Ask CRIU if this architecture/kernel/criu combination
// supports pre-copy (dirty memory tracking)
criuMigrationArgs := CriuMigrationArgs{
cmd: lxc.MIGRATE_FEATURE_CHECK,
stateDir: "",
function: "feature-check",
stop: ... | go | {
"resource": ""
} |
q176788 | preDumpLoop | test | func (s *migrationSourceWs) preDumpLoop(args *preDumpLoopArgs) (bool, error) {
// Do a CRIU pre-dump
criuMigrationArgs := CriuMigrationArgs{
cmd: lxc.MIGRATE_PRE_DUMP,
stop: false,
actionScript: false,
preDumpDir: args.preDumpDir,
dumpDir: args.dumpDir,
stateDir: args.checkpoin... | go | {
"resource": ""
} |
q176789 | newRoot | test | func newRoot() *cobra.Command {
cmd := &cobra.Command{
Use: "lxd-generate",
Short: "Code generation tool for LXD development",
Long: `This is the entry point for all "go:generate" directives
used in LXD's source code.`,
RunE: func(cmd *cobra.Command, args []string) error {
return fmt.Errorf("Not implement... | go | {
"resource": ""
} |
q176790 | APIExtensionsCount | test | func APIExtensionsCount() int {
count := len(APIExtensions)
// This environment variable is an internal one to force the code
// to believe that we an API extensions version greater than we
// actually have. It's used by integration tests to exercise the
// cluster upgrade process.
artificialBump := os.Getenv("L... | go | {
"resource": ""
} |
q176791 | SelectURIs | test | func SelectURIs(stmt *sql.Stmt, f func(a ...interface{}) string, args ...interface{}) ([]string, error) {
rows, err := stmt.Query(args...)
if err != nil {
return nil, errors.Wrapf(err, "Failed to query URIs")
}
defer rows.Close()
columns, err := rows.Columns()
if err != nil {
return nil, errors.Wrap(err, "Ro... | go | {
"resource": ""
} |
q176792 | SelectStrings | test | func SelectStrings(tx *sql.Tx, query string, args ...interface{}) ([]string, error) {
values := []string{}
scan := func(rows *sql.Rows) error {
var value string
err := rows.Scan(&value)
if err != nil {
return err
}
values = append(values, value)
return nil
}
err := scanSingleColumn(tx, query, args, ... | go | {
"resource": ""
} |
q176793 | scanSingleColumn | test | func scanSingleColumn(tx *sql.Tx, query string, args []interface{}, typeName string, scan scanFunc) error {
rows, err := tx.Query(query, args...)
if err != nil {
return err
}
defer rows.Close()
for rows.Next() {
err := scan(rows)
if err != nil {
return err
}
}
err = rows.Err()
if err != nil {
ret... | go | {
"resource": ""
} |
q176794 | LazyHandler | test | func LazyHandler(h Handler) Handler {
return FuncHandler(func(r *Record) error {
// go through the values (odd indices) and reassign
// the values of any lazy fn to the result of its execution
hadErr := false
for i := 1; i < len(r.Ctx); i += 2 {
lz, ok := r.Ctx[i].(Lazy)
if ok {
v, err := evaluateLaz... | go | {
"resource": ""
} |
q176795 | Callers | test | func Callers() Trace {
pcs := poolBuf()
pcs = pcs[:cap(pcs)]
n := runtime.Callers(2, pcs)
cs := make([]Call, n)
for i, pc := range pcs[:n] {
cs[i] = Call(pc)
}
putPoolBuf(pcs)
return cs
} | go | {
"resource": ""
} |
q176796 | name | test | func (pc Call) name() string {
pcFix := uintptr(pc) - 1 // work around for go issue #7690
fn := runtime.FuncForPC(pcFix)
if fn == nil {
return "???"
}
return fn.Name()
} | go | {
"resource": ""
} |
q176797 | TrimBelow | test | func (pcs Trace) TrimBelow(pc Call) Trace {
for len(pcs) > 0 && pcs[0] != pc {
pcs = pcs[1:]
}
return pcs
} | go | {
"resource": ""
} |
q176798 | TrimAbove | test | func (pcs Trace) TrimAbove(pc Call) Trace {
for len(pcs) > 0 && pcs[len(pcs)-1] != pc {
pcs = pcs[:len(pcs)-1]
}
return pcs
} | go | {
"resource": ""
} |
q176799 | TrimBelowName | test | func (pcs Trace) TrimBelowName(name string) Trace {
for len(pcs) > 0 && pcs[0].name() != name {
pcs = pcs[1:]
}
return pcs
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.