id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c176700 | ops := []bakery.Op{{
Entity: r.URL.Path,
Action: r.Method,
}}
info, err := authChecker.Allow(ctx, ops...)
if err != nil {
// Bad macaroon
return false, "", "", err
}
if info != nil && info.Identity != nil {
// Valid identity macaroon found
return true, info.Identity.Id(), "candid", nil
... | |
c176701 | state.NewState(d.db, d.cluster, d.maas, d.os, d.endpoints)
} | |
c176702 | path
}
return filepath.Join(d.os.VarDir, "unix.socket")
} | |
c176703 | }
logger.Infof("Closing the database")
err := d.cluster.Close()
// If we got io.EOF the network connection was interrupted and
// it's likely that the other node shutdown. Let's just log the
// event and return cleanly.
if errors.Cause(err) == driver.ErrBadConn {
logger.Debugf("Could not close remote d... | |
c176704 | PublicKey: bakery.PublicKey{Key: pkKey},
Version: 3,
})
// Allow http URLs if we have a public key set
if strings.HasPrefix(authEndpoint, "http://") {
pkLocator.AllowInsecure()
}
}
// Setup the bakery
bakery := identchecker.NewBakery(identchecker.BakeryParams{
Key: key,
Location: ... | |
c176705 | }
}
for _, i := range legacyPatchesNeedingDB {
legacy[i].NeedsDB = true
}
// Hook to run when the local database is created from scratch. It will
// create the default profile and mark all patches as applied.
freshHook := func(db *db.Node) error {
for _, patchName := range patchesGetNames() {
err := db.... | |
c176706 | }
err := json.NewEncoder(output).Encode(body)
if captured != nil {
shared.DebugJson(captured)
}
return err
} | |
c176707 | "", err
}
return fmt.Sprintf("%x", etag.Sum(nil)), nil
} | |
c176708 | err
}
if hash != match {
return fmt.Errorf("ETag doesn't match: %s vs %s", hash, match)
}
return nil
} | |
c176709 |
DisableKeepAlives: true,
}
myhttp := http.Client{
Transport: tr,
}
// Setup redirect policy
myhttp.CheckRedirect = func(req *http.Request, via []*http.Request) error {
// Replicate the headers
req.Header = via[len(via)-1].Header
return nil
}
return &myhttp, nil
} | |
c176710 |
recursion, err := strconv.Atoi(recursionStr)
if err != nil {
return false
}
return recursion != 0
} | |
c176711 | file := os.NewFile(uintptr(i), fmt.Sprintf("inherited-fd%d", i))
listener, err := net.FileListener(file)
if err != nil {
continue
}
listeners = append(listeners, listener)
}
return listeners
} | |
c176712 | schema = node.FreshSchema()
}
tx, err := db.Begin()
if err != nil {
return SmartError(errors.Wrap(err, "failed to start transaction"))
}
defer tx.Rollback()
dump, err := query.Dump(tx, schema, schemaOnly == 1)
if err != nil {
return SmartError(errors.Wrapf(err, "failed dump database %s", database))
}
ret... | |
c176713 | != nil {
return SmartError(err)
}
if strings.HasPrefix(strings.ToUpper(query), "SELECT") {
err = internalSQLSelect(tx, query, &result)
tx.Rollback()
} else {
err = internalSQLExec(tx, query, &result)
if err != nil {
tx.Rollback()
} else {
err = tx.Commit()
}
}
if err != nil {
... | |
c176714 | pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: data})
} | |
c176715 | ok {
data := x509.MarshalPKCS1PrivateKey(rsaKey)
return pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: data})
}
return nil
} | |
c176716 | 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
} | |
c176717 | certf, err)
}
certOut.Write(certBytes)
certOut.Close()
keyOut, err := os.OpenFile(keyf, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
if err != nil {
return fmt.Errorf("Failed to open %s for writing: %v", keyf, err)
}
keyOut.Write(keyBytes)
keyOut.Close()
return nil
} | |
c176718 | %s\n", env.KernelVersion)
fmt.Printf(" Storage backend: %s\n", env.Storage)
fmt.Printf(" Storage version: %s\n", env.StorageVersion)
fmt.Printf(" Container backend: %s\n", env.Driver)
fmt.Printf(" Container version: %s\n", env.DriverVersion)
fmt.Printf("\n")
return nil
} | |
c176719 | *sync.WaitGroup) {
defer wg.Done()
name := getContainerName(count, index)
err := createContainer(c, fingerprint, name, privileged)
if err != nil {
logf("Failed to launch container '%s': %s", name, err)
return
}
if start {
err := startContainer(c, name)
if err != nil {
logf("Failed to sta... | |
c176720 | }
batchCreate := func(index int, wg *sync.WaitGroup) {
defer wg.Done()
name := getContainerName(count, index)
err := createContainer(c, fingerprint, name, privileged)
if err != nil {
logf("Failed to launch container '%s': %s", name, err)
return
}
}
duration = processBatch(count, batchSize, batch... | |
c176721 | range allContainers {
if container.Config[userConfigKey] == "true" {
containers = append(containers, container)
}
}
return containers, nil
} | |
c176722 | count)
batchStart := func(index int, wg *sync.WaitGroup) {
defer wg.Done()
container := containers[index]
if !container.IsActive() {
err := startContainer(c, container.Name)
if err != nil {
logf("Failed to start container '%s': %s", container.Name, err)
return
}
}
}
duration = processBat... | |
c176723 |
return "", err
}
values := fields.Query()
values.Set(param, url.QueryEscape(value))
fields.RawQuery = values.Encode()
return fields.String(), nil
} | |
c176724 | nil, "", &images)
if err != nil {
return nil, err
}
return images, nil
} | |
c176725 | return r.GetPrivateImageFile(fingerprint, "", req)
} | |
c176726 | "", err
}
opAPI := op.Get()
return opAPI.Metadata["secret"].(string), nil
} | |
c176727 | != nil {
return nil, "", err
}
}
// Fetch the raw value
etag, err := r.queryStruct("GET", path, nil, "", &image)
if err != nil {
return nil, "", err
}
return &image, etag, nil
} | |
c176728 | if err == nil {
resp, err := lxdDownloadImage(fingerprint, unixURI, r.httpUserAgent, devlxdHTTP, req)
if err == nil {
return resp, nil
}
}
}
// Build the URL
uri = fmt.Sprintf("%s%s", r.httpHost, uri)
if secret != "" {
uri, err = setQueryParam(uri, "secret", secret)
if err != nil {
return n... | |
c176729 | err := r.queryStruct("GET", "/images/aliases?recursion=1", nil, "", &aliases)
if err != nil {
return nil, err
}
return aliases, nil
} | |
c176730 |
// Forward targetOp to remote op
go func() {
success := false
errors := map[string]error{}
for _, serverURL := range urls {
req.Source.Server = serverURL
op, err := r.CreateImage(req, nil)
if err != nil {
errors[serverURL] = err
continue
}
rop.targetOp = op
for _, handler := range... | |
c176731 | if err != nil {
return nil, err
}
req.Source.Secret = secret
}
// Process the arguments
if args != nil {
req.Aliases = args.Aliases
req.AutoUpdate = args.AutoUpdate
req.Public = args.Public
if args.CopyAliases {
req.Aliases = image.Aliases
if args.Aliases != nil {
req.Aliases = append(re... | |
c176732 | request
_, _, err := r.query("PUT", fmt.Sprintf("/images/%s", url.QueryEscape(fingerprint)), image, ETag)
if err != nil {
return err
}
return nil
} | |
c176733 | := r.queryOperation("DELETE", fmt.Sprintf("/images/%s", url.QueryEscape(fingerprint)), nil, "")
if err != nil {
return nil, err
}
return op, nil
} | |
c176734 | r.queryOperation("POST", fmt.Sprintf("/images/%s/refresh", url.QueryEscape(fingerprint)), nil, "")
if err != nil {
return nil, err
}
return op, nil
} | |
c176735 | the request
_, _, err := r.query("POST", "/images/aliases", alias, "")
if err != nil {
return err
}
return nil
} | |
c176736 | url.QueryEscape(name)), alias, ETag)
if err != nil {
return err
}
return nil
} | |
c176737 | request
_, _, err := r.query("POST", fmt.Sprintf("/images/aliases/%s", url.QueryEscape(name)), alias, "")
if err != nil {
return err
}
return nil
} | |
c176738 | := r.query("DELETE", fmt.Sprintf("/images/aliases/%s", url.QueryEscape(name)), nil, "")
if err != nil {
return err
}
return nil
} | |
c176739 |
return nil, fmt.Errorf("cannot open node database: %v", err)
}
return db, nil
} | |
c176740 | := shared.FileCopy(path, path+".bak")
if err != nil {
return err
}
backupDone = true
}
if version == -1 {
logger.Debugf("Running pre-update queries from file for local DB schema")
} else {
logger.Debugf("Updating DB schema from %d to %d", version, version+1)
}
// Run the given hook only... | |
c176741 | return "ext4", nil
case FilesystemSuperMagicXfs:
return "xfs", nil
case FilesystemSuperMagicNfs:
return "nfs", nil
default:
logger.Debugf("Unknown backing filesystem type: 0x%x", fs.Type)
return string(fs.Type), nil
}
} | |
c176742 |
schema.Fresh(freshSchema)
return schema
} | |
c176743 | err = tx.Exec(`
INSERT INTO config (key, value)
SELECT 'cluster.https_address', value FROM config WHERE key = 'core.https_address'
`)
if err != nil {
return errors.Wrap(err, "Insert cluster.https_address config")
}
return nil
} | |
c176744 | ArchitectureDefault, err
}
return uname.Machine, nil
} | |
c176745 | nil, err
}
// Find the right machine
machines, err := srv.Machines(gomaasapi.MachinesArgs{Hostnames: []string{machine}})
if err != nil {
return nil, err
}
if len(machines) != 1 {
return nil, fmt.Errorf("Couldn't find the specified machine: %s", machine)
}
// Setup the struct
c := Controller{}
c.srv = ... | |
c176746 | {
return
}
c.DeleteContainer(name)
}()
// Create the rest of the interfaces
for _, iface := range interfaces[1:] {
_, err := device.CreateInterface(gomaasapi.CreateInterfaceArgs{
Name: iface.Name,
MACAddress: iface.MACAddress,
VLAN: subnets[iface.Subnets[0].Name].VLAN(),
})
if er... | |
c176747 | return false, err
}
if len(devs) == 1 {
return true, nil
}
return false, nil
} | |
c176748 | _, ok := existingSubnets[subnet.Name]
if ok {
continue
}
// Add the link
err := entry.LinkSubnet(gomaasapi.LinkSubnetArgs{
Mode: gomaasapi.LinkModeStatic,
Subnet: subnets[subnet.Name],
IPAddress: subnet.Address,
})
if err != nil {
return err
}
}
// Record the in... | |
c176749 |
return err
}
values := url.Values{}
values.Set("hostname", newName)
_, err = c.srvRaw.Put(uri, values)
if err != nil {
return err
}
return nil
} | |
c176750 | if err != nil {
return err
}
err = device.Delete()
if err != nil {
return err
}
return nil
} | |
c176751 | append(s.updates, update)
} | |
c176752 | := createSchemaTable(tx)
if err != nil {
return fmt.Errorf("failed to create schema table: %v", err)
}
}
return nil
} | |
c176753 | if count == 1 {
// Insert the missing version.
err := insertSchemaVersion(tx, 38)
if err != nil {
return -1, fmt.Errorf("Failed to insert missing schema version 38")
}
versions = append(versions, 38)
}
}
current := 0
if len(versions) > 0 {
err = checkSchemaVersionsHaveNoHoles(versions)
if ... | |
c176754 | for _, update := range updates[current:] {
if hook != nil {
err := hook(current, tx)
if err != nil {
return fmt.Errorf(
"failed to execute hook (version %d): %v", current, err)
}
}
err := update(tx)
if err != nil {
return fmt.Errorf("failed to apply update %d: %v", current, err)
}
curr... | |
c176755 | 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
} | |
c176756 |
return fmt.Errorf("expected schema table to contain at least one row")
}
err = checkSchemaVersionsHaveNoHoles(versions)
if err != nil {
return err
}
current := versions[len(versions)-1]
if current != len(updates) {
return fmt.Errorf("update level is %d, expected %d", current, len(updates))
}
return nil... | |
c176757 |
lines[i] = strings.Replace(line, ", ", ",\n ", -1)
}
return strings.Join(lines, "\n")
} | |
c176758 | split = split[:len(split)-1]
}
xattrs = make(map[string]string, len(split))
for _, x := range split {
xattr := string(x)
// Call Getxattr() 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 in th... | |
c176759 |
}
tmpErrno, ok := err.(syscall.Errno)
if ok {
return tmpErrno, true
}
return nil, false
} | |
c176760 |
Sysname: intArrayToString(uname.Sysname),
Nodename: intArrayToString(uname.Nodename),
Release: intArrayToString(uname.Release),
Version: intArrayToString(uname.Version),
Machine: intArrayToString(uname.Machine),
Domainname: intArrayToString(uname.Domainname),
}, nil
} | |
c176761 |
stmts[code] = sql
return code
} | |
c176762 | return nil, errors.Wrapf(err, "%q", sql)
}
index[code] = stmt
}
return index, nil
} | |
c176763 | ctx: ctx,
cancel: cancel,
upgradeCh: make(chan struct{}, 16),
acceptCh: make(chan net.Conn),
store: &dqliteServerStore{},
}
err := gateway.init()
if err != nil {
return nil, err
}
return gateway, nil
} | |
c176764 | g.memoryDial(ctx, address)
}
return dqliteNetworkDial(ctx, address, g.cert)
}
} | |
c176765 | g.Sync()
g.server.Close()
// Unset the memory dial, since Shutdown() is also called for
// switching between in-memory and network mode.
g.memoryDial = nil
}
return nil
} | |
c176766 | 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)
}
} | |
c176767 | error {
return tx.RaftNodesReplace(nil)
})
if err != nil {
return err
}
g.cert = cert
return g.init()
} | |
c176768 | node.Address)
}
return nil
})
if err != nil {
return "", errors.Wrap(err, "Failed to fetch raft nodes addresses")
}
if len(addresses) == 0 {
// This should never happen because the raft_nodes table should
// be never empty for a clustered node, but check it for good
// measure.
return "", fmt.Errorf... | |
c176769 |
return fmt.Errorf("RAFT node did not self-elect within %s", time.Duration(n)*sleep)
} | |
c176770 | {
if err != db.ErrNoSuchObject {
return nil, errors.Wrap(err, "Failed to fetch raft server address")
}
// Use the initial address as fallback. This is an edge
// case that happens when a new leader is elected and
// its raft_nodes table is not fully up-to-date yet.
address = server.Address
}
... | |
c176771 |
if err != nil {
return nil, errors.Wrap(err, "Failed to fetch raft nodes")
}
return addresses, nil
} | |
c176772 | error) {
return net.Dial("unix", listener.Addr().String())
}
} | |
c176773 | logger.Debugf(format, a...)
case dqlite.LogWarn:
logger.Warnf(format, a...)
case dqlite.LogError:
logger.Errorf(format, a...)
}
} | |
c176774 | r.MetadataAsStruct(&ret)
if err != nil {
return nil, err
}
return ret, nil
} | |
c176775 | Operation{}
err := r.MetadataAsStruct(&op)
if err != nil {
return nil, err
}
return &op, nil
} | |
c176776 | []string{}
err := r.MetadataAsStruct(&sl)
if err != nil {
return nil, err
}
return sl, nil
} | |
c176777 | json.Unmarshal(r.Metadata, &target)
} | |
c176778 |
}
err = r.addRecord(record)
if err != nil {
return err
}
}
logf("Loaded report file %s", r.Filename)
return nil
} | |
c176779 | writer.WriteAll(r.records)
if err != nil {
return err
}
logf("Written report file %s", r.Filename)
return nil
} | |
c176780 | fmt.Sprintf("%d", time.Now().UnixNano()/int64(time.Millisecond)), // timestamp
fmt.Sprintf("%d", elapsed/time.Millisecond),
label,
"", // responseCode is not used
"true", // success"
}
return r.addRecord(record)
} | |
c176781 |
c.Remotes[k] = v
}
// NOTE: Remove this once we only see a small fraction of non-simplestreams users
// Upgrade users to the "simplestreams" protocol
images, ok := c.Remotes["images"]
if ok && images.Protocol != ImagesRemote.Protocol && images.Addr == ImagesRemote.Addr {
c.Remotes["images"] = ImagesRemote
... | |
c176782 | %v", err)
}
defer f.Close()
// Write the new config
data, err := yaml.Marshal(conf)
if err != nil {
return fmt.Errorf("Unable to marshal the configuration: %v", err)
}
_, err = f.Write(data)
if err != nil {
return fmt.Errorf("Unable to write the configuration: %v", err)
}
return nil
} | |
c176783 | return nil, err
}
// Validate that we're under the expected prefix
if !strings.HasPrefix(path, basePath) {
return nil, fmt.Errorf("Attempting to access a file outside the container")
}
// Open and read the file
buf, err := ioutil.ReadFile(path)
if err != nil {
return nil, err
}
return bytes.NewReader(... | |
c176784 | = append(path, paths...)
return filepath.Join(path...)
} | |
c176785 | {
return c.ConfigPath("servercerts", fmt.Sprintf("%s.crt", remote))
} | |
c176786 | DefaultRemotes
config.DefaultRemote = "local"
}
return config
} | |
c176787 | of memory pages is below the defined threshold.
tmp = s.container.ExpandedConfig()["migration.incremental.memory.iterations"]
if tmp != "" {
max_iterations, _ = strconv.Atoi(tmp)
} else {
// default to 10
max_iterations = 10
}
if max_iterations > 999 {
// the pre-dump directory is hardcoded to a string
... | |
c176788 | be pre-copied for the pre-copy migration to stop.
var threshold int
tmp := s.container.ExpandedConfig()["migration.incremental.memory.goal"]
if tmp != "" {
threshold, _ = strconv.Atoi(tmp)
} else {
// defaults to 70%
threshold = 70
}
if percentage_skipped > threshold {
logger.Debugf("Memory pages skippe... | |
c176789 | 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 implemented")
},
}
cmd.AddCommand(newDb())
return cmd
} | |
c176790 | artificialBump := os.Getenv("LXD_ARTIFICIALLY_BUMP_API_EXTENSIONS")
if artificialBump != "" {
n, err := strconv.Atoi(artificialBump)
if err == nil {
count += n
}
}
return count
} | |
c176791 | := []string{}
for rows.Next() {
err := rows.Scan(dest...)
if err != nil {
return nil, errors.Wrapf(err, "Failed to scan URI params")
}
uri := f(params...)
uris = append(uris, uri)
}
err = rows.Err()
if err != nil {
return nil, errors.Wrapf(err, "Failed to close URI result set")
}
return uris, ... | |
c176792 | err := rows.Scan(&value)
if err != nil {
return err
}
values = append(values, value)
return nil
}
err := scanSingleColumn(tx, query, args, "TEXT", scan)
if err != nil {
return nil, err
}
return values, nil
} | |
c176793 | for rows.Next() {
err := scan(rows)
if err != nil {
return err
}
}
err = rows.Err()
if err != nil {
return err
}
return nil
} | |
c176794 | := r.Ctx[i].(Lazy)
if ok {
v, err := evaluateLazy(lz)
if err != nil {
hadErr = true
r.Ctx[i] = err
} else {
if cs, ok := v.(stack.Trace); ok {
v = cs.TrimBelow(stack.Call(r.CallPC[0])).
TrimRuntime()
}
r.Ctx[i] = v
}
}
}
if hadErr {
r.Ctx = append(r.C... | |
c176795 | pc := range pcs[:n] {
cs[i] = Call(pc)
}
putPoolBuf(pcs)
return cs
} | |
c176796 | if fn == nil {
return "???"
}
return fn.Name()
} | |
c176797 | for len(pcs) > 0 && pcs[0] != pc {
pcs = pcs[1:]
}
return pcs
} | |
c176798 | pcs = pcs[:len(pcs)-1]
}
return pcs
} | |
c176799 |
for len(pcs) > 0 && pcs[0].name() != name {
pcs = pcs[1:]
}
return pcs
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.