_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q177100 | activatedListeners | test | func activatedListeners(systemdListeners []net.Listener, cert *shared.CertInfo) map[kind]net.Listener {
listeners := map[kind]net.Listener{}
for _, listener := range systemdListeners {
var kind kind
switch listener.(type) {
case *net.UnixListener:
kind = local
case *net.TCPListener:
kind = network
li... | go | {
"resource": ""
} |
q177101 | CandidServer | test | func (c *Config) CandidServer() (string, string, int64, string) {
return c.m.GetString("candid.api.url"),
c.m.GetString("candid.api.key"),
c.m.GetInt64("candid.expiry"),
c.m.GetString("candid.domains")
} | go | {
"resource": ""
} |
q177102 | RBACServer | test | func (c *Config) RBACServer() (string, string, int64, string, string, string, string) {
return c.m.GetString("rbac.api.url"),
c.m.GetString("rbac.api.key"),
c.m.GetInt64("rbac.expiry"),
c.m.GetString("rbac.agent.url"),
c.m.GetString("rbac.agent.username"),
c.m.GetString("rbac.agent.private_key"),
c.m.GetSt... | go | {
"resource": ""
} |
q177103 | AutoUpdateInterval | test | func (c *Config) AutoUpdateInterval() time.Duration {
n := c.m.GetInt64("images.auto_update_interval")
return time.Duration(n) * time.Hour
} | go | {
"resource": ""
} |
q177104 | MAASController | test | func (c *Config) MAASController() (string, string) {
url := c.m.GetString("maas.api.url")
key := c.m.GetString("maas.api.key")
return url, key
} | go | {
"resource": ""
} |
q177105 | OfflineThreshold | test | func (c *Config) OfflineThreshold() time.Duration {
n := c.m.GetInt64("cluster.offline_threshold")
return time.Duration(n) * time.Second
} | go | {
"resource": ""
} |
q177106 | ConfigGetString | test | func ConfigGetString(cluster *db.Cluster, key string) (string, error) {
config, err := configGet(cluster)
if err != nil {
return "", err
}
return config.m.GetString(key), nil
} | go | {
"resource": ""
} |
q177107 | ConfigGetBool | test | func ConfigGetBool(cluster *db.Cluster, key string) (bool, error) {
config, err := configGet(cluster)
if err != nil {
return false, err
}
return config.m.GetBool(key), nil
} | go | {
"resource": ""
} |
q177108 | ConfigGetInt64 | test | func ConfigGetInt64(cluster *db.Cluster, key string) (int64, error) {
config, err := configGet(cluster)
if err != nil {
return 0, err
}
return config.m.GetInt64(key), nil
} | go | {
"resource": ""
} |
q177109 | ClusterAddress | test | func (e *Endpoints) ClusterAddress() string {
e.mu.RLock()
defer e.mu.RUnlock()
listener := e.listeners[cluster]
if listener == nil {
return ""
}
return listener.Addr().String()
} | go | {
"resource": ""
} |
q177110 | Debug | test | func Debug(msg string, ctx ...interface{}) {
if Log != nil {
pc, fn, line, _ := runtime.Caller(1)
msg := fmt.Sprintf("%s: %d: %s: %s", fn, line, runtime.FuncForPC(pc).Name(), msg)
Log.Debug(msg, ctx...)
}
} | go | {
"resource": ""
} |
q177111 | RestServer | test | func RestServer(d *Daemon) *http.Server {
/* Setup the web server */
mux := mux.NewRouter()
mux.StrictSlash(false)
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
SyncResponse(true, []string{"/1.0"}).Render(w)
})
for endpoint, f := range ... | go | {
"resource": ""
} |
q177112 | projectParam | test | func projectParam(request *http.Request) string {
project := queryParam(request, "project")
if project == "" {
project = "default"
}
return project
} | go | {
"resource": ""
} |
q177113 | queryParam | test | func queryParam(request *http.Request, key string) string {
var values url.Values
var err error
if request.URL != nil {
values, err = url.ParseQuery(request.URL.RawQuery)
if err != nil {
logger.Warnf("Failed to parse query string %q: %v", request.URL.RawQuery, err)
return ""
}
}
if values == nil {
... | go | {
"resource": ""
} |
q177114 | newDb | test | func newDb() *cobra.Command {
cmd := &cobra.Command{
Use: "db [sub-command]",
Short: "Database-related code generation.",
RunE: func(cmd *cobra.Command, args []string) error {
return fmt.Errorf("Not implemented")
},
}
cmd.AddCommand(newDbSchema())
cmd.AddCommand(newDbMapper())
return cmd
} | go | {
"resource": ""
} |
q177115 | Description | test | func (t OperationType) Description() string {
switch t {
case OperationClusterBootstrap:
return "Creating bootstrap node"
case OperationClusterJoin:
return "Joining cluster"
case OperationBackupCreate:
return "Backing up container"
case OperationBackupRename:
return "Renaming container backup"
case Operat... | go | {
"resource": ""
} |
q177116 | Permission | test | func (t OperationType) Permission() string {
switch t {
case OperationBackupCreate:
return "operate-containers"
case OperationBackupRename:
return "operate-containers"
case OperationBackupRestore:
return "operate-containers"
case OperationBackupRemove:
return "operate-containers"
case OperationConsoleShow... | go | {
"resource": ""
} |
q177117 | OperationsUUIDs | test | func (c *ClusterTx) OperationsUUIDs() ([]string, error) {
stmt := "SELECT uuid FROM operations WHERE node_id=?"
return query.SelectStrings(c.tx, stmt, c.nodeID)
} | go | {
"resource": ""
} |
q177118 | OperationNodes | test | func (c *ClusterTx) OperationNodes(project string) ([]string, error) {
stmt := `
SELECT DISTINCT nodes.address
FROM operations
LEFT OUTER JOIN projects ON projects.id = operations.project_id
JOIN nodes ON nodes.id = operations.node_id
WHERE projects.name = ? OR operations.project_id IS NULL
`
return query.Sele... | go | {
"resource": ""
} |
q177119 | OperationByUUID | test | func (c *ClusterTx) OperationByUUID(uuid string) (Operation, error) {
null := Operation{}
operations, err := c.operations("uuid=?", uuid)
if err != nil {
return null, err
}
switch len(operations) {
case 0:
return null, ErrNoSuchObject
case 1:
return operations[0], nil
default:
return null, fmt.Errorf("m... | go | {
"resource": ""
} |
q177120 | OperationAdd | test | func (c *ClusterTx) OperationAdd(project, uuid string, typ OperationType) (int64, error) {
var projectID interface{}
if project != "" {
var err error
projectID, err = c.ProjectID(project)
if err != nil {
return -1, errors.Wrap(err, "Fetch project ID")
}
} else {
projectID = nil
}
columns := []string... | go | {
"resource": ""
} |
q177121 | OperationRemove | test | func (c *ClusterTx) OperationRemove(uuid string) error {
result, err := c.tx.Exec("DELETE FROM operations WHERE uuid=?", uuid)
if err != nil {
return err
}
n, err := result.RowsAffected()
if err != nil {
return err
}
if n != 1 {
return fmt.Errorf("query deleted %d rows instead of 1", n)
}
return nil
} | go | {
"resource": ""
} |
q177122 | operations | test | func (c *ClusterTx) operations(where string, args ...interface{}) ([]Operation, error) {
operations := []Operation{}
dest := func(i int) []interface{} {
operations = append(operations, Operation{})
return []interface{}{
&operations[i].ID,
&operations[i].UUID,
&operations[i].NodeAddress,
&operations[i]... | go | {
"resource": ""
} |
q177123 | expireLogsTask | test | func expireLogsTask(state *state.State) (task.Func, task.Schedule) {
f := func(ctx context.Context) {
opRun := func(op *operation) error {
return expireLogs(ctx, state)
}
op, err := operationCreate(state.Cluster, "", operationClassTask, db.OperationLogsExpire, nil, nil, opRun, nil, nil)
if err != nil {
... | go | {
"resource": ""
} |
q177124 | absPath | test | func absPath(path string) string {
// We expect to be called by code within the lxd package itself.
_, filename, _, _ := runtime.Caller(1)
elems := strings.Split(filename, string(filepath.Separator))
for i := len(elems) - 1; i >= 0; i-- {
if elems[i] == "lxd" {
elems = append([]string{string(filepath.Separato... | go | {
"resource": ""
} |
q177125 | Keys | test | func (s Schema) Keys() []string {
keys := make([]string, len(s))
i := 0
for key := range s {
keys[i] = key
i++
}
sort.Strings(keys)
return keys
} | go | {
"resource": ""
} |
q177126 | Defaults | test | func (s Schema) Defaults() map[string]interface{} {
values := make(map[string]interface{}, len(s))
for name, key := range s {
values[name] = key.Default
}
return values
} | go | {
"resource": ""
} |
q177127 | mustGetKey | test | func (s Schema) mustGetKey(name string) Key {
key, ok := s[name]
if !ok {
panic(fmt.Sprintf("attempt to access unknown key '%s'", name))
}
return key
} | go | {
"resource": ""
} |
q177128 | assertKeyType | test | func (s Schema) assertKeyType(name string, code Type) {
key := s.mustGetKey(name)
if key.Type != code {
panic(fmt.Sprintf("key '%s' has type code %d, not %d", name, key.Type, code))
}
} | go | {
"resource": ""
} |
q177129 | validate | test | func (v *Key) validate(value string) error {
validator := v.Validator
if validator == nil {
// Dummy validator
validator = func(string) error { return nil }
}
// Handle unsetting
if value == "" {
return validator(v.Default)
}
switch v.Type {
case String:
case Bool:
if !shared.StringInSlice(strings.To... | go | {
"resource": ""
} |
q177130 | GetStoragePoolVolumes | test | func (r *ProtocolLXD) GetStoragePoolVolumes(pool string) ([]api.StorageVolume, error) {
if !r.HasExtension("storage") {
return nil, fmt.Errorf("The server is missing the required \"storage\" API extension")
}
volumes := []api.StorageVolume{}
// Fetch the raw value
_, err := r.queryStruct("GET", fmt.Sprintf("/s... | go | {
"resource": ""
} |
q177131 | GetStoragePoolVolume | test | func (r *ProtocolLXD) GetStoragePoolVolume(pool string, volType string, name string) (*api.StorageVolume, string, error) {
if !r.HasExtension("storage") {
return nil, "", fmt.Errorf("The server is missing the required \"storage\" API extension")
}
volume := api.StorageVolume{}
// Fetch the raw value
path := fm... | go | {
"resource": ""
} |
q177132 | CreateStoragePoolVolume | test | func (r *ProtocolLXD) CreateStoragePoolVolume(pool string, volume api.StorageVolumesPost) error {
if !r.HasExtension("storage") {
return fmt.Errorf("The server is missing the required \"storage\" API extension")
}
// Send the request
path := fmt.Sprintf("/storage-pools/%s/volumes/%s", url.QueryEscape(pool), url.... | go | {
"resource": ""
} |
q177133 | CreateStoragePoolVolumeSnapshot | test | func (r *ProtocolLXD) CreateStoragePoolVolumeSnapshot(pool string, volumeType string, volumeName string, snapshot api.StorageVolumeSnapshotsPost) (Operation, error) {
if !r.HasExtension("storage_api_volume_snapshots") {
return nil, fmt.Errorf("The server is missing the required \"storage_api_volume_snapshots\" API e... | go | {
"resource": ""
} |
q177134 | GetStoragePoolVolumeSnapshots | test | func (r *ProtocolLXD) GetStoragePoolVolumeSnapshots(pool string, volumeType string, volumeName string) ([]api.StorageVolumeSnapshot, error) {
if !r.HasExtension("storage_api_volume_snapshots") {
return nil, fmt.Errorf("The server is missing the required \"storage_api_volume_snapshots\" API extension")
}
snapshots... | go | {
"resource": ""
} |
q177135 | GetStoragePoolVolumeSnapshot | test | func (r *ProtocolLXD) GetStoragePoolVolumeSnapshot(pool string, volumeType string, volumeName string, snapshotName string) (*api.StorageVolumeSnapshot, string, error) {
if !r.HasExtension("storage_api_volume_snapshots") {
return nil, "", fmt.Errorf("The server is missing the required \"storage_api_volume_snapshots\"... | go | {
"resource": ""
} |
q177136 | UpdateStoragePoolVolumeSnapshot | test | func (r *ProtocolLXD) UpdateStoragePoolVolumeSnapshot(pool string, volumeType string, volumeName string, snapshotName string, volume api.StorageVolumeSnapshotPut, ETag string) error {
if !r.HasExtension("storage_api_volume_snapshots") {
return fmt.Errorf("The server is missing the required \"storage_api_volume_snaps... | go | {
"resource": ""
} |
q177137 | MigrateStoragePoolVolume | test | func (r *ProtocolLXD) MigrateStoragePoolVolume(pool string, volume api.StorageVolumePost) (Operation, error) {
if !r.HasExtension("storage_api_remote_volume_handling") {
return nil, fmt.Errorf("The server is missing the required \"storage_api_remote_volume_handling\" API extension")
}
// Sanity check
if !volume.... | go | {
"resource": ""
} |
q177138 | MoveStoragePoolVolume | test | func (r *ProtocolLXD) MoveStoragePoolVolume(pool string, source ContainerServer, sourcePool string, volume api.StorageVolume, args *StoragePoolVolumeMoveArgs) (RemoteOperation, error) {
if !r.HasExtension("storage_api_local_volume_handling") {
return nil, fmt.Errorf("The server is missing the required \"storage_api_... | go | {
"resource": ""
} |
q177139 | UpdateStoragePoolVolume | test | func (r *ProtocolLXD) UpdateStoragePoolVolume(pool string, volType string, name string, volume api.StorageVolumePut, ETag string) error {
if !r.HasExtension("storage") {
return fmt.Errorf("The server is missing the required \"storage\" API extension")
}
if volume.Restore != "" && !r.HasExtension("storage_api_volu... | go | {
"resource": ""
} |
q177140 | DeleteStoragePoolVolume | test | func (r *ProtocolLXD) DeleteStoragePoolVolume(pool string, volType string, name string) error {
if !r.HasExtension("storage") {
return fmt.Errorf("The server is missing the required \"storage\" API extension")
}
// Send the request
path := fmt.Sprintf("/storage-pools/%s/volumes/%s/%s", url.QueryEscape(pool), url... | go | {
"resource": ""
} |
q177141 | RenameStoragePoolVolume | test | func (r *ProtocolLXD) RenameStoragePoolVolume(pool string, volType string, name string, volume api.StorageVolumePost) error {
if !r.HasExtension("storage_api_volume_rename") {
return fmt.Errorf("The server is missing the required \"storage_api_volume_rename\" API extension")
}
path := fmt.Sprintf("/storage-pools/%... | go | {
"resource": ""
} |
q177142 | doStoragePoolCreateInternal | test | func doStoragePoolCreateInternal(state *state.State, poolName, poolDescription string, driver string, config map[string]string, isNotification bool) error {
tryUndo := true
s, err := storagePoolInit(state, poolName)
if err != nil {
return err
}
// If this is a clustering notification for a ceph storage, we don'... | go | {
"resource": ""
} |
q177143 | containerGetParentAndSnapshotName | test | func containerGetParentAndSnapshotName(name string) (string, string, bool) {
fields := strings.SplitN(name, shared.SnapshotDelimiter, 2)
if len(fields) == 1 {
return name, "", false
}
return fields[0], fields[1], true
} | go | {
"resource": ""
} |
q177144 | containerLoadFromAllProjects | test | func containerLoadFromAllProjects(s *state.State) ([]container, error) {
var projects []string
err := s.Cluster.Transaction(func(tx *db.ClusterTx) error {
var err error
projects, err = tx.ProjectNames()
return err
})
if err != nil {
return nil, err
}
containers := []container{}
for _, project := range ... | go | {
"resource": ""
} |
q177145 | containerLoadNodeAll | test | func containerLoadNodeAll(s *state.State) ([]container, error) {
// Get all the container arguments
var cts []db.Container
err := s.Cluster.Transaction(func(tx *db.ClusterTx) error {
var err error
cts, err = tx.ContainerNodeList()
if err != nil {
return err
}
return nil
})
if err != nil {
return ni... | go | {
"resource": ""
} |
q177146 | containerLoadNodeProjectAll | test | func containerLoadNodeProjectAll(s *state.State, project string) ([]container, error) {
// Get all the container arguments
var cts []db.Container
err := s.Cluster.Transaction(func(tx *db.ClusterTx) error {
var err error
cts, err = tx.ContainerNodeProjectList(project)
if err != nil {
return err
}
return... | go | {
"resource": ""
} |
q177147 | heartbeatNode | test | func heartbeatNode(taskCtx context.Context, address string, cert *shared.CertInfo, raftNodes []db.RaftNode) error {
logger.Debugf("Sending heartbeat request to %s", address)
config, err := tlsClientConfig(cert)
if err != nil {
return err
}
url := fmt.Sprintf("https://%s%s", address, databaseEndpoint)
client :=... | go | {
"resource": ""
} |
q177148 | dotPrefixMatch | test | func (c *cmdList) dotPrefixMatch(short string, full string) bool {
fullMembs := strings.Split(full, ".")
shortMembs := strings.Split(short, ".")
if len(fullMembs) != len(shortMembs) {
return false
}
for i := range fullMembs {
if !strings.HasPrefix(fullMembs[i], shortMembs[i]) {
return false
}
}
retur... | go | {
"resource": ""
} |
q177149 | ContainerMount | test | func (s *storageZfs) ContainerMount(c container) (bool, error) {
return s.doContainerMount(c.Project(), c.Name(), c.IsPrivileged())
} | go | {
"resource": ""
} |
q177150 | ContainerStorageReady | test | func (s *storageZfs) ContainerStorageReady(container container) bool {
volumeName := projectPrefix(container.Project(), container.Name())
fs := fmt.Sprintf("containers/%s", volumeName)
return zfsFilesystemEntityExists(s.getOnDiskPoolName(), fs)
} | go | {
"resource": ""
} |
q177151 | AskChoice | test | func AskChoice(question string, choices []string, defaultAnswer string) string {
for {
answer := askQuestion(question, defaultAnswer)
if shared.StringInSlice(answer, choices) {
return answer
}
invalidInput()
}
} | go | {
"resource": ""
} |
q177152 | AskInt | test | func AskInt(question string, min int64, max int64, defaultAnswer string) int64 {
for {
answer := askQuestion(question, defaultAnswer)
result, err := strconv.ParseInt(answer, 10, 64)
if err == nil && (min == -1 || result >= min) && (max == -1 || result <= max) {
return result
}
invalidInput()
}
} | go | {
"resource": ""
} |
q177153 | AskString | test | func AskString(question string, defaultAnswer string, validate func(string) error) string {
for {
answer := askQuestion(question, defaultAnswer)
if validate != nil {
error := validate(answer)
if error != nil {
fmt.Fprintf(os.Stderr, "Invalid input: %s\n\n", error)
continue
}
return answer
}... | go | {
"resource": ""
} |
q177154 | AskPassword | test | func AskPassword(question string) string {
for {
fmt.Printf(question)
pwd, _ := terminal.ReadPassword(0)
fmt.Println("")
inFirst := string(pwd)
inFirst = strings.TrimSuffix(inFirst, "\n")
fmt.Printf("Again: ")
pwd, _ = terminal.ReadPassword(0)
fmt.Println("")
inSecond := string(pwd)
inSecond = st... | go | {
"resource": ""
} |
q177155 | AskPasswordOnce | test | func AskPasswordOnce(question string) string {
fmt.Printf(question)
pwd, _ := terminal.ReadPassword(0)
fmt.Println("")
return string(pwd)
} | go | {
"resource": ""
} |
q177156 | askQuestion | test | func askQuestion(question, defaultAnswer string) string {
fmt.Printf(question)
return readAnswer(defaultAnswer)
} | go | {
"resource": ""
} |
q177157 | readAnswer | test | func readAnswer(defaultAnswer string) string {
answer, _ := stdin.ReadString('\n')
answer = strings.TrimSuffix(answer, "\n")
answer = strings.TrimSpace(answer)
if answer == "" {
answer = defaultAnswer
}
return answer
} | go | {
"resource": ""
} |
q177158 | profilePost | test | func profilePost(d *Daemon, r *http.Request) Response {
project := projectParam(r)
name := mux.Vars(r)["name"]
if name == "default" {
return Forbidden(errors.New("The 'default' profile cannot be renamed"))
}
req := api.ProfilePost{}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
return BadRequ... | go | {
"resource": ""
} |
q177159 | profileDelete | test | func profileDelete(d *Daemon, r *http.Request) Response {
project := projectParam(r)
name := mux.Vars(r)["name"]
if name == "default" {
return Forbidden(errors.New("The 'default' profile cannot be deleted"))
}
err := d.cluster.Transaction(func(tx *db.ClusterTx) error {
hasProfiles, err := tx.ProjectHasProfil... | go | {
"resource": ""
} |
q177160 | IsRootDiskDevice | test | func IsRootDiskDevice(device map[string]string) bool {
if device["type"] == "disk" && device["path"] == "/" && device["source"] == "" {
return true
}
return false
} | go | {
"resource": ""
} |
q177161 | GetRootDiskDevice | test | func GetRootDiskDevice(devices map[string]map[string]string) (string, map[string]string, error) {
var devName string
var dev map[string]string
for n, d := range devices {
if IsRootDiskDevice(d) {
if devName != "" {
return "", nil, fmt.Errorf("More than one root device found")
}
devName = n
dev = ... | go | {
"resource": ""
} |
q177162 | ForwardedResponse | test | func ForwardedResponse(client lxd.ContainerServer, request *http.Request) Response {
return &forwardedResponse{
client: client,
request: request,
}
} | go | {
"resource": ""
} |
q177163 | ForwardedResponseIfTargetIsRemote | test | func ForwardedResponseIfTargetIsRemote(d *Daemon, request *http.Request) Response {
targetNode := queryParam(request, "target")
if targetNode == "" {
return nil
}
// Figure out the address of the target node (which is possibly
// this very same node).
address, err := cluster.ResolveTarget(d.cluster, targetNode... | go | {
"resource": ""
} |
q177164 | ForwardedResponseIfContainerIsRemote | test | func ForwardedResponseIfContainerIsRemote(d *Daemon, r *http.Request, project, name string) (Response, error) {
cert := d.endpoints.NetworkCert()
client, err := cluster.ConnectIfContainerIsRemote(d.cluster, project, name, cert)
if err != nil {
return nil, err
}
if client == nil {
return nil, nil
}
return For... | go | {
"resource": ""
} |
q177165 | ForwardedOperationResponse | test | func ForwardedOperationResponse(project string, op *api.Operation) Response {
return &forwardedOperationResponse{
op: op,
project: project,
}
} | go | {
"resource": ""
} |
q177166 | Done | test | func (p *ProgressRenderer) Done(msg string) {
// Acquire rendering lock
p.lock.Lock()
defer p.lock.Unlock()
// Check if we're already done
if p.done {
return
}
// Mark this renderer as done
p.done = true
// Handle quiet mode
if p.Quiet {
msg = ""
}
// Truncate msg to terminal length
msg = p.truncat... | go | {
"resource": ""
} |
q177167 | Update | test | func (p *ProgressRenderer) Update(status string) {
// Wait if needed
timeout := p.wait.Sub(time.Now())
if timeout.Seconds() > 0 {
time.Sleep(timeout)
}
// Acquire rendering lock
p.lock.Lock()
defer p.lock.Unlock()
// Check if we're already done
if p.done {
return
}
// Handle quiet mode
if p.Quiet {
... | go | {
"resource": ""
} |
q177168 | Warn | test | func (p *ProgressRenderer) Warn(status string, timeout time.Duration) {
// Acquire rendering lock
p.lock.Lock()
defer p.lock.Unlock()
// Check if we're already done
if p.done {
return
}
// Render the new message
p.wait = time.Now().Add(timeout)
msg := fmt.Sprintf("%s", status)
// Truncate msg to terminal... | go | {
"resource": ""
} |
q177169 | UpdateProgress | test | func (p *ProgressRenderer) UpdateProgress(progress ioprogress.ProgressData) {
p.Update(progress.Text)
} | go | {
"resource": ""
} |
q177170 | UpdateOp | test | func (p *ProgressRenderer) UpdateOp(op api.Operation) {
if op.Metadata == nil {
return
}
for key, value := range op.Metadata {
if !strings.HasSuffix(key, "_progress") {
continue
}
p.Update(value.(string))
break
}
} | go | {
"resource": ""
} |
q177171 | updateFromV6 | test | func updateFromV6(tx *sql.Tx) error {
// Fetch the IDs of all existing nodes.
nodeIDs, err := query.SelectIntegers(tx, "SELECT id FROM nodes")
if err != nil {
return errors.Wrap(err, "failed to get IDs of current nodes")
}
// Fetch the IDs of all existing zfs pools.
poolIDs, err := query.SelectIntegers(tx, `
S... | go | {
"resource": ""
} |
q177172 | localCreateListener | test | func localCreateListener(path string, group string) (net.Listener, error) {
err := CheckAlreadyRunning(path)
if err != nil {
return nil, err
}
err = socketUnixRemoveStale(path)
if err != nil {
return nil, err
}
listener, err := socketUnixListen(path)
if err != nil {
return nil, err
}
err = localSetAc... | go | {
"resource": ""
} |
q177173 | NewStmt | test | func NewStmt(database, pkg, entity, kind string, config map[string]string) (*Stmt, error) {
packages, err := Packages()
if err != nil {
return nil, err
}
stmt := &Stmt{
db: database,
pkg: pkg,
entity: entity,
kind: kind,
config: config,
packages: packages,
}
return stmt, nil
} | go | {
"resource": ""
} |
q177174 | Generate | test | func (s *Stmt) Generate(buf *file.Buffer) error {
if strings.HasPrefix(s.kind, "objects") {
return s.objects(buf)
}
if strings.HasPrefix(s.kind, "create") && strings.HasSuffix(s.kind, "-ref") {
return s.createRef(buf)
}
if strings.HasSuffix(s.kind, "-ref") || strings.Contains(s.kind, "-ref-by-") {
return s... | go | {
"resource": ""
} |
q177175 | register | test | func (s *Stmt) register(buf *file.Buffer, sql string, filters ...string) {
kind := strings.Replace(s.kind, "-", "_", -1)
if kind == "id" {
kind = "ID" // silence go lints
}
buf.L("var %s = %s.RegisterStmt(`\n%s\n`)", stmtCodeVar(s.entity, kind, filters...), s.db, sql)
} | go | {
"resource": ""
} |
q177176 | httpsLXD | test | func httpsLXD(url string, args *ConnectionArgs) (ContainerServer, error) {
// Use empty args if not specified
if args == nil {
args = &ConnectionArgs{}
}
// Initialize the client struct
server := ProtocolLXD{
httpCertificate: args.TLSServerCert,
httpHost: url,
httpProtocol: "https",
httpUse... | go | {
"resource": ""
} |
q177177 | IsActive | test | func (c Container) IsActive() bool {
switch c.StatusCode {
case Stopped:
return false
case Error:
return false
default:
return true
}
} | go | {
"resource": ""
} |
q177178 | RaftNodeAddress | test | func (n *NodeTx) RaftNodeAddress(id int64) (string, error) {
stmt := "SELECT address FROM raft_nodes WHERE id=?"
addresses, err := query.SelectStrings(n.tx, stmt, id)
if err != nil {
return "", err
}
switch len(addresses) {
case 0:
return "", ErrNoSuchObject
case 1:
return addresses[0], nil
default:
// ... | go | {
"resource": ""
} |
q177179 | RaftNodeFirst | test | func (n *NodeTx) RaftNodeFirst(address string) error {
columns := []string{"id", "address"}
values := []interface{}{int64(1), address}
id, err := query.UpsertObject(n.tx, "raft_nodes", columns, values)
if err != nil {
return err
}
if id != 1 {
return fmt.Errorf("could not set raft node ID to 1")
}
return ni... | go | {
"resource": ""
} |
q177180 | RaftNodeAdd | test | func (n *NodeTx) RaftNodeAdd(address string) (int64, error) {
columns := []string{"address"}
values := []interface{}{address}
return query.UpsertObject(n.tx, "raft_nodes", columns, values)
} | go | {
"resource": ""
} |
q177181 | RaftNodeDelete | test | func (n *NodeTx) RaftNodeDelete(id int64) error {
deleted, err := query.DeleteObject(n.tx, "raft_nodes", id)
if err != nil {
return err
}
if !deleted {
return ErrNoSuchObject
}
return nil
} | go | {
"resource": ""
} |
q177182 | RaftNodesReplace | test | func (n *NodeTx) RaftNodesReplace(nodes []RaftNode) error {
_, err := n.tx.Exec("DELETE FROM raft_nodes")
if err != nil {
return err
}
columns := []string{"id", "address"}
for _, node := range nodes {
values := []interface{}{node.ID, node.Address}
_, err := query.UpsertObject(n.tx, "raft_nodes", columns, va... | go | {
"resource": ""
} |
q177183 | initCGroup | test | func (s *OS) initCGroup() {
flags := []*bool{
&s.CGroupBlkioController,
&s.CGroupCPUController,
&s.CGroupCPUacctController,
&s.CGroupCPUsetController,
&s.CGroupDevicesController,
&s.CGroupFreezerController,
&s.CGroupMemoryController,
&s.CGroupNetPrioController,
&s.CGroupPidsController,
&s.CGroupSwa... | go | {
"resource": ""
} |
q177184 | sqliteDirectAccess | test | func sqliteDirectAccess(conn *sqlite3.SQLiteConn) error {
// Ensure journal mode is set to WAL, as this is a requirement for
// replication.
_, err := conn.Exec("PRAGMA journal_mode=wal", nil)
if err != nil {
return err
}
// Ensure we don't truncate or checkpoint the WAL on exit, as this
// would bork replica... | go | {
"resource": ""
} |
q177185 | ContainerGet | test | func (c *ClusterTx) ContainerGet(project string, name string) (*Container, error) {
filter := ContainerFilter{}
filter.Project = project
filter.Name = name
filter.Type = -1
objects, err := c.ContainerList(filter)
if err != nil {
return nil, errors.Wrap(err, "Failed to fetch Container")
}
switch len(objects)... | go | {
"resource": ""
} |
q177186 | ContainerID | test | func (c *ClusterTx) ContainerID(project string, name string) (int64, error) {
stmt := c.stmt(containerID)
rows, err := stmt.Query(project, name)
if err != nil {
return -1, errors.Wrap(err, "Failed to get container ID")
}
defer rows.Close()
// For sanity, make sure we read one and only one row.
if !rows.Next()... | go | {
"resource": ""
} |
q177187 | ContainerExists | test | func (c *ClusterTx) ContainerExists(project string, name string) (bool, error) {
_, err := c.ContainerID(project, name)
if err != nil {
if err == ErrNoSuchObject {
return false, nil
}
return false, err
}
return true, nil
} | go | {
"resource": ""
} |
q177188 | ContainsFields | test | func (m *Mapping) ContainsFields(fields []*Field) bool {
matches := map[*Field]bool{}
for _, field := range m.Fields {
for _, other := range fields {
if field.Name == other.Name && field.Type.Name == other.Type.Name {
matches[field] = true
}
}
}
return len(matches) == len(fields)
} | go | {
"resource": ""
} |
q177189 | FieldByName | test | func (m *Mapping) FieldByName(name string) *Field {
for _, field := range m.Fields {
if field.Name == name {
return field
}
}
return nil
} | go | {
"resource": ""
} |
q177190 | FieldColumnName | test | func (m *Mapping) FieldColumnName(name string) string {
field := m.FieldByName(name)
return fmt.Sprintf("%s.%s", entityTable(m.Name), field.Column())
} | go | {
"resource": ""
} |
q177191 | FilterFieldByName | test | func (m *Mapping) FilterFieldByName(name string) (*Field, error) {
field := m.FieldByName(name)
if field == nil {
return nil, fmt.Errorf("Unknown filter %q", name)
}
if field.Type.Code != TypeColumn {
return nil, fmt.Errorf("Unknown filter %q not a column", name)
}
return field, nil
} | go | {
"resource": ""
} |
q177192 | ColumnFields | test | func (m *Mapping) ColumnFields(exclude ...string) []*Field {
fields := []*Field{}
for _, field := range m.Fields {
if shared.StringInSlice(field.Name, exclude) {
continue
}
if field.Type.Code == TypeColumn {
fields = append(fields, field)
}
}
return fields
} | go | {
"resource": ""
} |
q177193 | ScalarFields | test | func (m *Mapping) ScalarFields() []*Field {
fields := []*Field{}
for _, field := range m.Fields {
if field.Config.Get("join") != "" {
fields = append(fields, field)
}
}
return fields
} | go | {
"resource": ""
} |
q177194 | RefFields | test | func (m *Mapping) RefFields() []*Field {
fields := []*Field{}
for _, field := range m.Fields {
if field.Type.Code == TypeSlice || field.Type.Code == TypeMap {
fields = append(fields, field)
}
}
return fields
} | go | {
"resource": ""
} |
q177195 | Column | test | func (f *Field) Column() string {
if f.Type.Code != TypeColumn {
panic("attempt to get column name of non-column field")
}
column := lex.Snake(f.Name)
join := f.Config.Get("join")
if join != "" {
column = fmt.Sprintf("%s AS %s", join, column)
}
return column
} | go | {
"resource": ""
} |
q177196 | ZeroValue | test | func (f *Field) ZeroValue() string {
if f.Type.Code != TypeColumn {
panic("attempt to get zero value of non-column field")
}
switch f.Type.Name {
case "string":
return `""`
case "int":
// FIXME: we use -1 since at the moment integer criteria are
// required to be positive.
return "-1"
default:
panic(... | go | {
"resource": ""
} |
q177197 | FieldColumns | test | func FieldColumns(fields []*Field) string {
columns := make([]string, len(fields))
for i, field := range fields {
columns[i] = field.Column()
}
return strings.Join(columns, ", ")
} | go | {
"resource": ""
} |
q177198 | FieldArgs | test | func FieldArgs(fields []*Field) string {
args := make([]string, len(fields))
for i, field := range fields {
args[i] = fmt.Sprintf("%s %s", lex.Minuscule(field.Name), field.Type.Name)
}
return strings.Join(args, ", ")
} | go | {
"resource": ""
} |
q177199 | FieldParams | test | func FieldParams(fields []*Field) string {
args := make([]string, len(fields))
for i, field := range fields {
args[i] = lex.Minuscule(field.Name)
}
return strings.Join(args, ", ")
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.