id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c176600 | API extension")
}
// Send the request
_, _, err := r.query("DELETE", fmt.Sprintf("/containers/%s/files?path=%s", url.QueryEscape(containerName), url.QueryEscape(path)), nil, "")
if err != nil {
return err
}
return nil
} | |
c176601 | := strings.Split(uri, fmt.Sprintf("/containers/%s/snapshots/", url.QueryEscape(containerName)))
names = append(names, fields[len(fields)-1])
}
return names, nil
} | |
c176602 | url.QueryEscape(containerName)), nil, "", &snapshots)
if err != nil {
return nil, err
}
return snapshots, nil
} | |
c176603 | url.QueryEscape(containerName), url.QueryEscape(name)), nil, "", &snapshot)
if err != nil {
return nil, "", err
}
return &snapshot, etag, nil
} | |
c176604 | // Send the request
op, _, err := r.queryOperation("POST", fmt.Sprintf("/containers/%s/snapshots", url.QueryEscape(containerName)), snapshot, "")
if err != nil {
return nil, err
}
return op, nil
} | |
c176605 | := r.queryOperation("POST", fmt.Sprintf("/containers/%s/snapshots/%s", url.QueryEscape(containerName), url.QueryEscape(name)), container, "")
if err != nil {
return nil, err
}
return op, nil
} | |
c176606 | _, err := r.queryOperation("PUT", fmt.Sprintf("/containers/%s/snapshots/%s",
url.QueryEscape(containerName), url.QueryEscape(name)), container, ETag)
if err != nil {
return nil, err
}
return op, nil
} | |
c176607 | url.QueryEscape(name)), nil, "", &state)
if err != nil {
return nil, "", err
}
return &state, etag, nil
} | |
c176608 | url.QueryEscape(name)), state, ETag)
if err != nil {
return nil, err
}
return op, nil
} | |
c176609 | := strings.Split(uri, fmt.Sprintf("/containers/%s/logs/", url.QueryEscape(name)))
logfiles = append(logfiles, fields[len(fields)-1])
}
return logfiles, nil
} | |
c176610 |
req.Header.Set("User-Agent", r.httpUserAgent)
}
// Send the request
resp, err := r.do(req)
if err != nil {
return nil, err
}
// Check the return value for a cleaner error
if resp.StatusCode != http.StatusOK {
_, _, err := lxdParseResponse(resp)
if err != nil {
return nil, err
}
}
return resp.Body, err
} | |
c176611 | \"container_edit_metadata\" API extension")
}
metadata := api.ImageMetadata{}
url := fmt.Sprintf("/containers/%s/metadata", url.QueryEscape(name))
etag, err := r.queryStruct("GET", url, nil, "", &metadata)
if err != nil {
return nil, "", err
}
return &metadata, etag, err
} | |
c176612 | }
url := fmt.Sprintf("/containers/%s/metadata", url.QueryEscape(name))
_, _, err := r.query("PUT", url, metadata, ETag)
if err != nil {
return err
}
return nil
} | |
c176613 | API extension")
}
templates := []string{}
url := fmt.Sprintf("/containers/%s/metadata/templates", url.QueryEscape(containerName))
_, err := r.queryStruct("GET", url, nil, "", &templates)
if err != nil {
return nil, err
}
return templates, nil
} | |
c176614 | string, content io.ReadSeeker) error {
return r.setContainerTemplateFile(containerName, templateName, content, "POST")
} | |
c176615 | is missing the required \"container_edit_metadata\" API extension")
}
_, _, err := r.query("DELETE", fmt.Sprintf("/containers/%s/metadata/templates?path=%s", url.QueryEscape(name), url.QueryEscape(templateName)), nil, "")
return err
} | |
c176616 | nil {
return nil, err
}
go args.Control(controlConn)
// Connect to the websocket
conn, err := r.GetOperationWebsocket(opAPI.ID, fds["0"])
if err != nil {
return nil, err
}
// Detach from console.
go func(consoleDisconnect <-chan bool) {
<-consoleDisconnect
msg := websocket.FormatCloseMessage(websocket.CloseNormalClosure, "Detaching from console")
// We don't care if this fails. This is just for convenience.
controlConn.WriteMessage(websocket.CloseMessage, msg)
controlConn.Close()
}(args.ConsoleDisconnect)
// And attach stdin and stdout to it
go func() {
shared.WebsocketSendStream(conn, args.Terminal, -1)
<-shared.WebsocketRecvStream(args.Terminal, conn)
conn.Close()
}()
return op, nil
} | |
c176617 | nil, err
}
// Set the user agent
if r.httpUserAgent != "" {
req.Header.Set("User-Agent", r.httpUserAgent)
}
// Send the request
resp, err := r.do(req)
if err != nil {
return nil, err
}
// Check the return value for a cleaner error
if resp.StatusCode != http.StatusOK {
_, _, err := lxdParseResponse(resp)
if err != nil {
return nil, err
}
}
return resp.Body, err
} | |
c176618 | _, err := r.query("DELETE", fmt.Sprintf("/containers/%s/console", url.QueryEscape(containerName)), nil, "")
if err != nil {
return err
}
return nil
} | |
c176619 | _, err := r.queryStruct("GET", fmt.Sprintf("/containers/%s/backups?recursion=1", url.QueryEscape(containerName)), nil, "", &backups)
if err != nil {
return nil, err
}
return backups, nil
} | |
c176620 | err := r.queryStruct("GET", fmt.Sprintf("/containers/%s/backups/%s", url.QueryEscape(containerName), url.QueryEscape(name)), nil, "", &backup)
if err != nil {
return nil, "", err
}
return &backup, etag, nil
} | |
c176621 | _, err := r.queryOperation("POST", fmt.Sprintf("/containers/%s/backups",
url.QueryEscape(containerName)), backup, "")
if err != nil {
return nil, err
}
return op, nil
} | |
c176622 | _, err := r.queryOperation("POST", fmt.Sprintf("/containers/%s/backups/%s",
url.QueryEscape(containerName), url.QueryEscape(name)), backup, "")
if err != nil {
return nil, err
}
return op, nil
} | |
c176623 | r.queryOperation("DELETE", fmt.Sprintf("/containers/%s/backups/%s",
url.QueryEscape(containerName), url.QueryEscape(name)), nil, "")
if err != nil {
return nil, err
}
return op, nil
} | |
c176624 | }
// Handle the data
body := response.Body
if req.ProgressHandler != nil {
body = &ioprogress.ProgressReader{
ReadCloser: response.Body,
Tracker: &ioprogress.ProgressTracker{
Length: response.ContentLength,
Handler: func(percent int64, speed int64) {
req.ProgressHandler(ioprogress.ProgressData{Text: fmt.Sprintf("%d%% (%s/s)", percent, shared.GetByteSizeString(speed, 2))})
},
},
}
}
size, err := io.Copy(req.BackupFile, body)
if err != nil {
return nil, err
}
resp := BackupFileResponse{}
resp.Size = size
return &resp, nil
} | |
c176625 | err = cmd.Wait()
if err != nil {
dataSocket.Close()
readPipe.Close()
}
chError <- err
}()
output, err := ioutil.ReadAll(stderr)
if err != nil {
cmd.Process.Kill()
}
err = <-chError
if err != nil {
logger.Errorf("Rsync send failed: %s: %s: %s", path, err, string(output))
}
<-readDone
<-writeDone
return err
} | |
c176626 |
for i, patch := range patches {
names[i] = patch.name
}
return names
} | |
c176627 | err != nil {
return err
}
vgName := poolName
if pool.Config["lvm.vg_name"] != "" {
vgName = pool.Config["lvm.vg_name"]
}
for _, volume := range volumes {
oldName := fmt.Sprintf("%s/custom_%s", vgName, volume)
newName := fmt.Sprintf("%s/custom_%s", vgName, containerNameToLVName(volume))
exists, err := storageLVExists(newName)
if err != nil {
return err
}
if exists || oldName == newName {
continue
}
err = lvmLVRename(vgName, oldName, newName)
if err != nil {
return err
}
logger.Info("Successfully renamed LV", log.Ctx{"old_name": oldName, "new_name": newName})
}
}
return nil
} | |
c176628 | }
// Delete the current key
_, err = tx.Exec(`
DELETE FROM storage_pools_config WHERE key=? AND storage_pool_id=? AND node_id IS NULL
`, key, poolID)
if err != nil {
return errors.Wrapf(err, "failed to delete %s config", key)
}
// Add the config entry for each node
for _, nodeID := range nodeIDs {
_, err := tx.Exec(`
INSERT INTO storage_pools_config(storage_pool_id, node_id, key, value)
VALUES(?, ?, ?, ?)
`, poolID, nodeID, key, value)
if err != nil {
return errors.Wrapf(err, "failed to create %s node config", key)
}
}
}
}
err = tx.Commit()
if err != nil {
return errors.Wrap(err, "failed to commit transaction")
}
return err
} | |
c176629 | isn't set, bad connection")
}
return r.http, nil
} | |
c176630 | != nil {
r.addMacaroonHeaders(req)
return r.bakeryClient.Do(req)
}
return r.http.Do(req)
} | |
c176631 | url := fmt.Sprintf("%s%s", r.httpHost, path)
return r.rawQuery(method, url, data, ETag)
} | |
c176632 | (*websocket.Conn, error) {
return r.websocket(path)
} | |
c176633 | error) {
return r.queryOperation(method, path, data, ETag)
} | |
c176634 | profile.Description
p.Config = profile.Config
p.Devices = profile.Devices
return p
} | |
c176635 | var name string
outfmt := []interface{}{name}
result, err := queryScan(c.db, q, inargs, outfmt)
if err != nil {
return []string{}, err
}
response := []string{}
for _, r := range result {
response = append(response, r[0].(string))
}
return response, nil
} | |
c176636 | name)
if err != nil {
return err
}
result = ProfileToAPI(profile)
id = int64(profile.ID)
return nil
})
if err != nil {
return -1, nil, err
}
return id, result, nil
} | |
c176637 | profile, err := tx.ProfileGet(project, name)
if err != nil {
return errors.Wrapf(err, "Load profile %q", name)
}
profiles[i] = *ProfileToAPI(profile)
}
return nil
})
if err != nil {
return nil, err
}
return profiles, nil
} | |
c176638 | make sure the
* profile really exists; if it doesn't, let's send back a 404.
*/
query := "SELECT id FROM profiles WHERE name=?"
var id int
results, err := queryScan(c.db, query, []interface{}{name}, []interface{}{id})
if err != nil {
return nil, err
}
if len(results) == 0 {
return nil, ErrNoSuchObject
}
}
config := map[string]string{}
for _, r := range results {
key = r[0].(string)
value = r[1].(string)
config[key] = value
}
return config, nil
} | |
c176639 |
FROM profiles_devices_config JOIN profiles_devices
ON profiles_devices_config.profile_device_id=profiles_devices.id
WHERE profiles_devices.profile_id=?)`, id)
if err != nil {
return err
}
_, err = tx.Exec("DELETE FROM profiles_devices WHERE profile_id=?", id)
if err != nil {
return err
}
return nil
} | |
c176640 | return err
}
for k, v := range config {
if v == "" {
continue
}
_, err = stmt.Exec(id, k, v)
if err != nil {
return err
}
}
return nil
} | |
c176641 | WHERE profiles.name=? AND projects.name=?)
AND containers.type == 0`
results := map[string][]string{}
inargs := []interface{}{profile, project}
var name string
outfmt := []interface{}{name, name}
output, err := queryScan(c.db, q, inargs, outfmt)
if err != nil {
return nil, err
}
for _, r := range output {
if results[r[1].(string)] == nil {
results[r[1].(string)] = []string{}
}
results[r[1].(string)] = append(results[r[1].(string)], r[0].(string))
}
return results, nil
} | |
c176642 | FROM profiles_devices_config WHERE profile_device_id NOT IN (SELECT id FROM profiles_devices);
`
err := exec(c.db, stmt)
if err != nil {
return err
}
return nil
} | |
c176643 | i := range profileConfigs {
for k, v := range profileConfigs[i] {
expandedConfig[k] = v
}
}
// Stick the given config on top
for k, v := range config {
expandedConfig[k] = v
}
return expandedConfig
} | |
c176644 | := range profileDevices {
for k, v := range profileDevices[i] {
expandedDevices[k] = v
}
}
// Stick the given devices on top
for k, v := range devices {
expandedDevices[k] = v
}
return expandedDevices
} | |
c176645 | && server.Environment.Certificate != "" {
var err error
server.Environment.CertificateFingerprint, err = shared.CertFingerprintStr(server.Environment.Certificate)
if err != nil {
return nil, "", err
}
}
if !server.Public && len(server.AuthMethods) == 0 {
// TLS is always available for LXD servers
server.AuthMethods = []string{"tls"}
}
// Add the value to the cache
r.server = &server
return &server, etag, nil
} | |
c176646 | := r.query("PUT", "", server, ETag)
if err != nil {
return err
}
return nil
} | |
c176647 | return true
}
for _, entry := range r.server.APIExtensions {
if entry == extension {
return true
}
}
return false
} | |
c176648 |
_, err := r.queryStruct("GET", "/resources", nil, "", &resources)
if err != nil {
return nil, err
}
return &resources, nil
} | |
c176649 | bakeryClient: r.bakeryClient,
bakeryInteractor: r.bakeryInteractor,
requireAuthenticated: r.requireAuthenticated,
clusterTarget: r.clusterTarget,
project: name,
}
} | |
c176650 | database connection).
openPath := fmt.Sprintf("%s?_busy_timeout=%d&_txlock=exclusive", path, timeout*1000)
// Open the database. If the file doesn't exist it is created.
return sql.Open("sqlite3_with_fk", openPath)
} | |
c176651 | "", nil, err
}
if address == "" {
// No node to promote
return "", nil, nil
}
// Update the local raft_table adding the new member and building a new
// list.
updatedRaftNodes := currentRaftNodes
err = gateway.db.Transaction(func(tx *db.NodeTx) error {
id, err := tx.RaftNodeAdd(address)
if err != nil {
return errors.Wrap(err, "failed to add new raft node")
}
updatedRaftNodes = append(updatedRaftNodes, db.RaftNode{ID: id, Address: address})
err = tx.RaftNodesReplace(updatedRaftNodes)
if err != nil {
return errors.Wrap(err, "failed to update raft nodes")
}
return nil
})
if err != nil {
return "", nil, err
}
return address, updatedRaftNodes, nil
} | |
c176652 | good measure (perhaps they were
// somehow leftover).
err = os.RemoveAll(state.OS.GlobalDatabaseDir())
if err != nil {
return errors.Wrap(err, "failed to remove existing raft data")
}
// Re-initialize the gateway. This will create a new raft factory an
// dqlite driver instance, which will be exposed over gRPC by the
// gateway handlers.
err = gateway.init()
if err != nil {
return errors.Wrap(err, "failed to re-initialize gRPC SQL gateway")
}
logger.Info(
"Joining dqlite raft cluster",
log15.Ctx{"id": id, "address": address, "target": target})
changer := gateway.raft.MembershipChanger()
err = changer.Join(raft.ServerID(id), raft.ServerAddress(target), 5*time.Second)
if err != nil {
return err
}
// Unlock regular access to our cluster database, and make sure our
// gateway still works correctly.
err = state.Cluster.ExitExclusive(func(tx *db.ClusterTx) error {
_, err := tx.Nodes()
return err
})
if err != nil {
return errors.Wrap(err, "cluster database initialization failed")
}
return nil
} | |
c176653 | {
return errors.Wrapf(err, "failed to clear node %s", name)
}
err = tx.NodeRemove(node.ID)
if err != nil {
return errors.Wrapf(err, "failed to remove node %s", name)
}
return nil
})
} | |
c176654 | }
n, err := util.CompareVersions(version, node.Version())
if err != nil {
result[i].Status = "Broken"
result[i].Message = "inconsistent version"
continue
}
if n == 1 {
// This node's version is lower, which means the
// version that the previous node in the loop has been
// upgraded.
version = node.Version()
}
}
// Update the state of online nodes that have been upgraded and whose
// schema is more recent than the rest of the nodes.
for i, node := range nodes {
if result[i].Status != "Online" {
continue
}
n, err := util.CompareVersions(version, node.Version())
if err != nil {
continue
}
if n == 2 {
result[i].Status = "Blocked"
result[i].Message = "waiting for other nodes to be upgraded"
}
}
return result, nil
} | |
c176655 | count, err = tx.NodesCount()
return err
})
return count, err
} | |
c176656 | return err
}
enabled = len(addresses) > 0
return nil
})
return enabled, err
} | |
c176657 | entries in raft_nodes")
}
if !hasClusterAddress {
return fmt.Errorf("no cluster.https_address config is set on this node")
}
if hasRaftNodes {
return fmt.Errorf("the node is already part of a cluster")
}
return nil
} | |
c176658 | errors.Wrap(err, "failed to fetch current cluster nodes")
}
if len(nodes) != 1 {
return fmt.Errorf("inconsistent state: found leftover entries in nodes")
}
return nil
} | |
c176659 | node.Address == address {
return fmt.Errorf("cluster already has node with address %s", address)
}
if node.Schema != schema {
return fmt.Errorf("schema version mismatch: cluster has %d", node.Schema)
}
if node.APIExtensions != api {
return fmt.Errorf("API version mismatch: cluster has %d", node.APIExtensions)
}
}
return nil
} | |
c176660 | return err
}
if message != "" {
return fmt.Errorf(message)
}
// Check that it's not the last node.
nodes, err := tx.Nodes()
if err != nil {
return err
}
if len(nodes) == 1 {
return fmt.Errorf("node is the only node in the cluster")
}
return nil
} | |
c176661 | basename)) {
return fmt.Errorf("inconsistent state: found leftover cluster certificate")
}
}
return nil
} | |
c176662 | fmt.Errorf("cannot fetch node config from database: %v", err)
}
m, err := config.SafeLoad(ConfigSchema, values)
if err != nil {
return nil, fmt.Errorf("failed to load node config: %v", err)
}
return &Config{tx: tx, m: m}, nil
} | |
c176663 | (map[string]string, error) {
return c.update(values)
} | |
c176664 | for name, value := range patch {
values[name] = value
}
return c.update(values)
} | |
c176665 | {
var err error
config, err = ConfigLoad(tx)
return err
})
if err != nil {
return "", err
}
return config.HTTPSAddress(), nil
} | |
c176666 | &cert.ID,
&cert.Fingerprint,
&cert.Type,
&cert.Name,
&cert.Certificate,
)
certs = append(certs, cert)
}
return rows.Err()
})
if err != nil {
return certs, err
}
return certs, nil
} | |
c176667 | ?`
if err = dbQueryRowScan(c.db, query, inargs, outfmt); err != nil {
if err == sql.ErrNoRows {
return nil, ErrNoSuchObject
}
return nil, err
}
return cert, err
} | |
c176668 | }
defer stmt.Close()
_, err = stmt.Exec(
cert.Fingerprint,
cert.Type,
cert.Name,
cert.Certificate,
)
if err != nil {
return err
}
return nil
})
return err
} | |
c176669 | fingerprint=?", fingerprint)
if err != nil {
return err
}
return nil
} | |
c176670 | certificates SET name=?, type=? WHERE fingerprint=?", certName, certType, fingerprint)
return err
})
return err
} | |
c176671 |
// http://stackoverflow.com/questions/15716302/so-reuseaddr-and-af-unix
//
// Note that this will force clients to reconnect when LXD is restarted.
err := socketUnixRemoveStale(path)
if err != nil {
return nil, err
}
listener, err := socketUnixListen(path)
if err != nil {
return nil, err
}
err = socketUnixSetPermissions(path, 0666)
if err != nil {
listener.Close()
return nil, err
}
return listener, nil
} | |
c176672 | return nil, err
}
configuration := future.Configuration()
return configuration.Servers, nil
} | |
c176673 | for raft to shutdown")
return fmt.Errorf("raft did not shutdown within %s", timeout)
}
err := i.logs.Close()
if err != nil {
return errors.Wrap(err, "failed to close boltdb logs store")
}
return nil
} | |
c176674 | logger,
Stream: layer,
MaxPool: 2,
Timeout: timeout,
ServerAddressProvider: &raftAddressProvider{db: db},
}
transport := raft.NewNetworkTransportWithConfig(config)
return transport, handler, layer, nil
} | |
c176675 | }
durations := []*time.Duration{
&config.HeartbeatTimeout,
&config.ElectionTimeout,
&config.CommitTimeout,
&config.LeaderLeaseTimeout,
}
for _, duration := range durations {
scale(duration)
}
config.SnapshotThreshold = 1024
config.TrailingLogs = 512
return config
} | |
c176676 | ID: conf.LocalID,
Address: trans.LocalAddr(),
}
configuration := raft.Configuration{
Servers: []raft.Server{server},
}
return raft.BootstrapCluster(conf, logs, logs, snaps, trans, configuration)
} | |
c176677 | of cores on the socket
// Note that we can't assume sequential core IDs
socketCores := map[uint64]bool{}
for _, thread := range threads {
if thread.socketID != v.socketID {
continue
}
socketCores[thread.coreID] = true
}
cur.Cores = uint64(len(socketCores))
} else {
cur = &c.Sockets[v.socketID]
}
cur.Socket = v.socketID
cur.NUMANode = v.numaNode
cur.Threads++
cur.Name = v.name
cur.Vendor = v.vendor
cur.Frequency = v.frequency
cur.FrequencyTurbo = v.frequencyTurbo
}
return &c, nil
} | |
c176678 | return nil, err
}
cached, err = strconv.ParseUint(line, 10, 64)
if err != nil {
return nil, err
}
found++
} else if strings.HasPrefix(line, "Buffers:") {
line, err = cleanLine(line[len("Buffers:"):])
if err != nil {
return nil, err
}
buffers, err = strconv.ParseUint(line, 10, 64)
if err != nil {
return nil, err
}
found++
}
if found == 4 {
break
}
}
mem.Total = total * 1024
mem.Used = (total - free - cached - buffers) * 1024
return &mem, err
} | |
c176679 |
if err != nil {
return nil, err
}
// Parse it
uuids := []string{}
for _, url := range urls {
fields := strings.Split(url, "/operations/")
uuids = append(uuids, fields[len(fields)-1])
}
return uuids, nil
} | |
c176680 | &apiOperations)
if err != nil {
return nil, err
}
// Turn it into just a list of operations
operations := []api.Operation{}
for _, v := range apiOperations {
for _, operation := range v {
operations = append(operations, operation)
}
}
return operations, nil
} | |
c176681 | value
etag, err := r.queryStruct("GET", fmt.Sprintf("/operations/%s", url.QueryEscape(uuid)), nil, "", &op)
if err != nil {
return nil, "", err
}
return &op, etag, nil
} | |
c176682 | path = fmt.Sprintf("%s?secret=%s", path, url.QueryEscape(secret))
}
return r.websocket(path)
} | |
c176683 |
break
}
time.Sleep(500 * time.Millisecond)
}
if err != nil {
return err
}
return nil
} | |
c176684 |
}
if pl.Driver != driver {
continue
}
if pl.Config[onDiskProperty] == onDiskPoolName {
return true, pl.Name, nil
}
}
return false, "", nil
} | |
c176685 | }
} else {
stmt = c.stmt(projectNames)
args = []interface{}{}
}
code := cluster.EntityTypes["project"]
formatter := cluster.EntityFormatURIs[code]
return query.SelectURIs(stmt, formatter, args...)
} | |
c176686 | return nil, errors.Wrap(err, "Failed to fetch field Config")
}
for i := range objects {
value := configObjects[objects[i].Name]
if value == nil {
value = map[string]string{}
}
objects[i].Config = value
}
// Fill field UsedBy.
usedByObjects, err := c.ProjectUsedByRef(filter)
if err != nil {
return nil, errors.Wrap(err, "Failed to fetch field UsedBy")
}
for i := range objects {
value := usedByObjects[objects[i].Name]
if value == nil {
value = []string{}
}
objects[i].UsedBy = value
}
return objects, nil
} | |
c176687 | {
case 0:
return nil, ErrNoSuchObject
case 1:
return &objects[0], nil
default:
return nil, fmt.Errorf("More than one project matches")
}
} | |
c176688 | if err != nil {
if err == ErrNoSuchObject {
return false, nil
}
return false, err
}
return true, nil
} | |
c176689 | errors.Wrap(err, "Failed to create project")
}
id, err := result.LastInsertId()
if err != nil {
return -1, errors.Wrap(err, "Failed to fetch project ID")
}
// Insert config reference.
stmt = c.stmt(projectCreateConfigRef)
for key, value := range object.Config {
_, err := stmt.Exec(id, key, value)
if err != nil {
return -1, errors.Wrap(err, "Insert config for project")
}
}
return id, nil
} | |
c176690 |
&objects[i].Value,
}
}
// Select.
err := query.SelectObjects(stmt, dest, args...)
if err != nil {
return nil, errors.Wrap(err, "Failed to fetch string ref for projects")
}
// Build index by primary name.
index := map[string][]string{}
for _, object := range objects {
item, ok := index[object.Name]
if !ok {
item = []string{}
}
index[object.Name] = append(item, object.Value)
}
return index, nil
} | |
c176691 | return errors.Wrap(err, "Fetch affected rows")
}
if n != 1 {
return fmt.Errorf("Query affected %d rows instead of 1", n)
}
return nil
} | |
c176692 | return errors.Wrap(err, "Fetch affected rows")
}
if n != 1 {
return fmt.Errorf("Query deleted %d rows instead of 1", n)
}
return nil
} | |
c176693 | hash, err := scrypt.Key([]byte(password), salt, 1<<14, 8, 1, 64)
if err != nil {
return err
}
if !bytes.Equal(hash, buff[32:]) {
return fmt.Errorf("Bad password provided")
}
return nil
} | |
c176694 |
prefix = "cluster"
}
cert, err := shared.KeyPairAndCA(dir, prefix, shared.CertServer)
if err != nil {
return nil, errors.Wrap(err, "failed to load TLS certificate")
}
return cert, nil
} | |
c176695 | return err
}
if ca != nil {
err = ioutil.WriteFile(filepath.Join(dir, prefix+".ca"), ca, 0644)
if err != nil {
return err
}
}
return nil
} | |
c176696 | make(chan struct{}),
readyChan: make(chan struct{}),
shutdownChan: make(chan struct{}),
}
} | |
c176697 |
os := sys.DefaultOS()
return NewDaemon(config, os)
} | |
c176698 | {
return EmptySyncResponse
}
// Get the project
project := projectParam(r)
// Validate whether the user has the needed permission
if !d.userHasPermission(r, project, permission) {
return Forbidden(nil)
}
return EmptySyncResponse
}
} | |
c176699 | return err
}
return fmt.Errorf("Not authorized")
}
return nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.