_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q176500 | GatherProwJobMetrics | test | func GatherProwJobMetrics(pjs []prowapi.ProwJob) {
// map of job to job type to state to count
metricMap := make(map[string]map[string]map[string]float64)
for _, pj := range pjs {
if metricMap[pj.Spec.Job] == nil {
metricMap[pj.Spec.Job] = make(map[string]map[string]float64)
}
if metricMap[pj.Spec.Job][str... | go | {
"resource": ""
} |
q176501 | optionOrDefault | test | func optionOrDefault(option, defaultValue time.Duration) time.Duration {
if option == 0 {
return defaultValue
}
return option
} | go | {
"resource": ""
} |
q176502 | newGCSJobSource | test | func newGCSJobSource(src string) (*gcsJobSource, error) {
gcsURL, err := url.Parse(fmt.Sprintf("gs://%s", src))
if err != nil {
return &gcsJobSource{}, ErrCannotParseSource
}
gcsPath := &gcs.Path{}
err = gcsPath.SetURL(gcsURL)
if err != nil {
return &gcsJobSource{}, ErrCannotParseSource
}
tokens := strings... | go | {
"resource": ""
} |
q176503 | artifacts | test | func (af *GCSArtifactFetcher) artifacts(key string) ([]string, error) {
src, err := newGCSJobSource(key)
if err != nil {
return nil, fmt.Errorf("Failed to get GCS job source from %s: %v", key, err)
}
listStart := time.Now()
bucketName, prefix := extractBucketPrefixPair(src.jobPath())
artifacts := []string{}
b... | go | {
"resource": ""
} |
q176504 | canonicalLink | test | func (src *gcsJobSource) canonicalLink() string {
return path.Join(src.linkPrefix, src.bucket, src.jobPrefix)
} | go | {
"resource": ""
} |
q176505 | jobPath | test | func (src *gcsJobSource) jobPath() string {
return fmt.Sprintf("%s/%s", src.bucket, src.jobPrefix)
} | go | {
"resource": ""
} |
q176506 | targetURL | test | func targetURL(c config.Getter, pr *PullRequest, log *logrus.Entry) string {
var link string
if tideURL := c().Tide.TargetURL; tideURL != "" {
link = tideURL
} else if baseURL := c().Tide.PRStatusBaseURL; baseURL != "" {
parseURL, err := url.Parse(baseURL)
if err != nil {
log.WithError(err).Error("Failed to... | go | {
"resource": ""
} |
q176507 | newBuildConfig | test | func newBuildConfig(cfg rest.Config, stop chan struct{}) (*buildConfig, error) {
bc, err := buildset.NewForConfig(&cfg)
if err != nil {
return nil, err
}
// Ensure the knative-build CRD is deployed
// TODO(fejta): probably a better way to do this
_, err = bc.BuildV1alpha1().Builds("").List(metav1.ListOptions{L... | go | {
"resource": ""
} |
q176508 | NewClient | test | func NewClient(token string, dryRun bool) *Client {
httpClient := &http.Client{
Transport: &oauth2.Transport{
Base: http.DefaultTransport,
Source: oauth2.ReuseTokenSource(nil, oauth2.StaticTokenSource(&oauth2.Token{AccessToken: token})),
},
}
client := github.NewClient(httpClient)
return &Client{
issu... | go | {
"resource": ""
} |
q176509 | retry | test | func (c *Client) retry(action string, call func() (*github.Response, error)) (*github.Response, error) {
var err error
var resp *github.Response
for retryCount := 0; retryCount <= c.retries; retryCount++ {
if resp, err = call(); err == nil {
c.limitRate(&resp.Rate)
return resp, nil
}
switch err := err.(... | go | {
"resource": ""
} |
q176510 | depaginate | test | func (c *Client) depaginate(action string, opts *github.ListOptions, call func() ([]interface{}, *github.Response, error)) ([]interface{}, error) {
var allItems []interface{}
wrapper := func() (*github.Response, error) {
items, resp, err := call()
if err == nil {
allItems = append(allItems, items...)
}
ret... | go | {
"resource": ""
} |
q176511 | NewHelpAgent | test | func NewHelpAgent(pa pluginAgent, ghc githubClient) *HelpAgent {
l := logrus.WithField("client", "plugin-help")
return &HelpAgent{
log: l,
pa: pa,
oa: newOrgAgent(l, ghc, newRepoDetectionLimit),
}
} | go | {
"resource": ""
} |
q176512 | GeneratePluginHelp | test | func (ha *HelpAgent) GeneratePluginHelp() *pluginhelp.Help {
config := ha.pa.Config()
orgToRepos := ha.oa.orgToReposMap(config)
normalRevMap, externalRevMap := reversePluginMaps(config, orgToRepos)
allPlugins, pluginHelp := ha.generateNormalPluginHelp(config, normalRevMap)
allExternalPlugins, externalPluginHelp... | go | {
"resource": ""
} |
q176513 | getPullCommitHash | test | func getPullCommitHash(pull string) (string, error) {
match := pullCommitRe.FindStringSubmatch(pull)
if len(match) != 2 {
expected := "branch:hash,pullNumber:hash"
return "", fmt.Errorf("unable to parse pull %q (expected %q)", pull, expected)
}
return match[1], nil
} | go | {
"resource": ""
} |
q176514 | listJobBuilds | test | func listJobBuilds(bucket storageBucket, jobPrefixes []string) []jobBuilds {
jobch := make(chan jobBuilds)
defer close(jobch)
for i, jobPrefix := range jobPrefixes {
go func(i int, jobPrefix string) {
buildPrefixes, err := bucket.listSubDirs(jobPrefix)
if err != nil {
logrus.WithError(err).Warningf("Erro... | go | {
"resource": ""
} |
q176515 | getPRBuildData | test | func getPRBuildData(bucket storageBucket, jobs []jobBuilds) []buildData {
buildch := make(chan buildData)
defer close(buildch)
expected := 0
for _, job := range jobs {
for j, buildPrefix := range job.buildPrefixes {
go func(j int, jobName, buildPrefix string) {
build, err := getBuildData(bucket, buildPrefi... | go | {
"resource": ""
} |
q176516 | getGCSDirsForPR | test | func getGCSDirsForPR(config *config.Config, org, repo string, pr int) (map[string]sets.String, error) {
toSearch := make(map[string]sets.String)
fullRepo := org + "/" + repo
presubmits, ok := config.Presubmits[fullRepo]
if !ok {
return toSearch, fmt.Errorf("couldn't find presubmits for %q in config", fullRepo)
}... | go | {
"resource": ""
} |
q176517 | imageDeleteFromDisk | test | func imageDeleteFromDisk(fingerprint string) {
// Remove main image file.
fname := shared.VarPath("images", fingerprint)
if shared.PathExists(fname) {
err := os.Remove(fname)
if err != nil && !os.IsNotExist(err) {
logger.Errorf("Error deleting image file %s: %s", fname, err)
}
}
// Remove the rootfs file... | go | {
"resource": ""
} |
q176518 | doNetworksCreate | test | func doNetworksCreate(d *Daemon, req api.NetworksPost, withDatabase bool) error {
// Start the network
n, err := networkLoadByName(d.State(), req.Name)
if err != nil {
return err
}
err = n.Start()
if err != nil {
n.Delete(withDatabase)
return err
}
return nil
} | go | {
"resource": ""
} |
q176519 | networkLoadByName | test | func networkLoadByName(s *state.State, name string) (*network, error) {
id, dbInfo, err := s.Cluster.NetworkGet(name)
if err != nil {
return nil, err
}
n := network{state: s, id: id, name: name, description: dbInfo.Description, config: dbInfo.Config}
return &n, nil
} | go | {
"resource": ""
} |
q176520 | Transaction | test | func (n *Node) Transaction(f func(*NodeTx) error) error {
nodeTx := &NodeTx{}
return query.Transaction(n.db, func(tx *sql.Tx) error {
nodeTx.tx = tx
return f(nodeTx)
})
} | go | {
"resource": ""
} |
q176521 | ForLocalInspectionWithPreparedStmts | test | func ForLocalInspectionWithPreparedStmts(db *sql.DB) (*Cluster, error) {
c := ForLocalInspection(db)
stmts, err := cluster.PrepareStmts(c.db)
if err != nil {
return nil, errors.Wrap(err, "Prepare database statements")
}
c.stmts = stmts
return c, nil
} | go | {
"resource": ""
} |
q176522 | SetDefaultTimeout | test | func (c *Cluster) SetDefaultTimeout(timeout time.Duration) {
driver := c.db.Driver().(*dqlite.Driver)
driver.SetContextTimeout(timeout)
} | go | {
"resource": ""
} |
q176523 | Transaction | test | func (c *Cluster) Transaction(f func(*ClusterTx) error) error {
c.mu.RLock()
defer c.mu.RUnlock()
return c.transaction(f)
} | go | {
"resource": ""
} |
q176524 | EnterExclusive | test | func (c *Cluster) EnterExclusive() error {
logger.Debug("Acquiring exclusive lock on cluster db")
ch := make(chan struct{})
go func() {
c.mu.Lock()
ch <- struct{}{}
}()
timeout := 20 * time.Second
select {
case <-ch:
return nil
case <-time.After(timeout):
return fmt.Errorf("timeout (%s)", timeout)
}
... | go | {
"resource": ""
} |
q176525 | ExitExclusive | test | func (c *Cluster) ExitExclusive(f func(*ClusterTx) error) error {
logger.Debug("Releasing exclusive lock on cluster db")
defer c.mu.Unlock()
return c.transaction(f)
} | go | {
"resource": ""
} |
q176526 | Close | test | func (c *Cluster) Close() error {
for _, stmt := range c.stmts {
stmt.Close()
}
return c.db.Close()
} | go | {
"resource": ""
} |
q176527 | TxCommit | test | func TxCommit(tx *sql.Tx) error {
err := tx.Commit()
if err == nil || err == sql.ErrTxDone { // Ignore duplicate commits/rollbacks
return nil
}
return err
} | go | {
"resource": ""
} |
q176528 | ParseRemote | test | func (c *Config) ParseRemote(raw string) (string, string, error) {
result := strings.SplitN(raw, ":", 2)
if len(result) == 1 {
return c.DefaultRemote, raw, nil
}
_, ok := c.Remotes[result[0]]
if !ok {
// Attempt to play nice with snapshots containing ":"
if shared.IsSnapshot(raw) && shared.IsSnapshot(result... | go | {
"resource": ""
} |
q176529 | GetContainerServer | test | func (c *Config) GetContainerServer(name string) (lxd.ContainerServer, error) {
// Get the remote
remote, ok := c.Remotes[name]
if !ok {
return nil, fmt.Errorf("The remote \"%s\" doesn't exist", name)
}
// Sanity checks
if remote.Public || remote.Protocol == "simplestreams" {
return nil, fmt.Errorf("The remo... | go | {
"resource": ""
} |
q176530 | GetImageServer | test | func (c *Config) GetImageServer(name string) (lxd.ImageServer, error) {
// Get the remote
remote, ok := c.Remotes[name]
if !ok {
return nil, fmt.Errorf("The remote \"%s\" doesn't exist", name)
}
// Get connection arguments
args, err := c.getConnectionArgs(name)
if err != nil {
return nil, err
}
// Unix s... | go | {
"resource": ""
} |
q176531 | initAppArmor | test | func (s *OS) initAppArmor() {
/* Detect AppArmor availability */
_, err := exec.LookPath("apparmor_parser")
if os.Getenv("LXD_SECURITY_APPARMOR") == "false" {
logger.Warnf("AppArmor support has been manually disabled")
} else if !shared.IsDir("/sys/kernel/security/apparmor") {
logger.Warnf("AppArmor support has... | go | {
"resource": ""
} |
q176532 | appArmorCanStack | test | func appArmorCanStack() bool {
contentBytes, err := ioutil.ReadFile("/sys/kernel/security/apparmor/features/domain/stack")
if err != nil {
return false
}
if string(contentBytes) != "yes\n" {
return false
}
contentBytes, err = ioutil.ReadFile("/sys/kernel/security/apparmor/features/domain/version")
if err !... | go | {
"resource": ""
} |
q176533 | containerDeviceAdd | test | func containerDeviceAdd(client lxd.ContainerServer, name string, devName string, dev map[string]string) error {
// Get the container entry
container, etag, err := client.GetContainer(name)
if err != nil {
return err
}
// Check if the device already exists
_, ok := container.Devices[devName]
if ok {
return f... | go | {
"resource": ""
} |
q176534 | profileDeviceAdd | test | func profileDeviceAdd(client lxd.ContainerServer, name string, devName string, dev map[string]string) error {
// Get the profile entry
profile, profileEtag, err := client.GetProfile(name)
if err != nil {
return err
}
// Check if the device already exists
_, ok := profile.Devices[devName]
if ok {
return fmt.... | go | {
"resource": ""
} |
q176535 | ensureImageAliases | test | func ensureImageAliases(client lxd.ContainerServer, aliases []api.ImageAlias, fingerprint string) error {
if len(aliases) == 0 {
return nil
}
names := make([]string, len(aliases))
for i, alias := range aliases {
names[i] = alias.Name
}
sort.Strings(names)
resp, err := client.GetImageAliases()
if err != ni... | go | {
"resource": ""
} |
q176536 | GetExistingAliases | test | func GetExistingAliases(aliases []string, allAliases []api.ImageAliasesEntry) []api.ImageAliasesEntry {
existing := []api.ImageAliasesEntry{}
for _, alias := range allAliases {
name := alias.Name
pos := sort.SearchStrings(aliases, name)
if pos < len(aliases) && aliases[pos] == name {
existing = append(existi... | go | {
"resource": ""
} |
q176537 | String | test | func (o StatusCode) String() string {
return map[StatusCode]string{
OperationCreated: "Operation created",
Started: "Started",
Stopped: "Stopped",
Running: "Running",
Cancelling: "Cancelling",
Pending: "Pending",
Success: "Success",
Failure: "... | go | {
"resource": ""
} |
q176538 | ImagesGetExpired | test | func (c *Cluster) ImagesGetExpired(expiry int64) ([]string, error) {
q := `SELECT fingerprint, last_use_date, upload_date FROM images WHERE cached=1`
var fpStr string
var useStr string
var uploadStr string
inargs := []interface{}{}
outfmt := []interface{}{fpStr, useStr, uploadStr}
dbResults, err := queryScan(c... | go | {
"resource": ""
} |
q176539 | ImageSourceInsert | test | func (c *Cluster) ImageSourceInsert(id int, server string, protocol string, certificate string, alias string) error {
stmt := `INSERT INTO images_source (image_id, server, protocol, certificate, alias) values (?, ?, ?, ?, ?)`
protocolInt := -1
for protoInt, protoString := range ImageSourceProtocol {
if protoStrin... | go | {
"resource": ""
} |
q176540 | ImageSourceGet | test | func (c *Cluster) ImageSourceGet(imageID int) (int, api.ImageSource, error) {
q := `SELECT id, server, protocol, certificate, alias FROM images_source WHERE image_id=?`
id := 0
protocolInt := -1
result := api.ImageSource{}
arg1 := []interface{}{imageID}
arg2 := []interface{}{&id, &result.Server, &protocolInt, &... | go | {
"resource": ""
} |
q176541 | ImageExists | test | func (c *Cluster) ImageExists(project string, fingerprint string) (bool, error) {
err := c.Transaction(func(tx *ClusterTx) error {
enabled, err := tx.ProjectHasImages(project)
if err != nil {
return errors.Wrap(err, "Check if project has images")
}
if !enabled {
project = "default"
}
return nil
})
... | go | {
"resource": ""
} |
q176542 | ImageGet | test | func (c *Cluster) ImageGet(project, fingerprint string, public bool, strictMatching bool) (int, *api.Image, error) {
err := c.Transaction(func(tx *ClusterTx) error {
enabled, err := tx.ProjectHasImages(project)
if err != nil {
return errors.Wrap(err, "Check if project has images")
}
if !enabled {
project... | go | {
"resource": ""
} |
q176543 | ImageGetFromAnyProject | test | func (c *Cluster) ImageGetFromAnyProject(fingerprint string) (int, *api.Image, error) {
var create, expire, used, upload *time.Time // These hold the db-returned times
// The object we'll actually return
image := api.Image{}
id := -1
arch := -1
// These two humongous things will be filled by the call to DbQuery... | go | {
"resource": ""
} |
q176544 | imageFill | test | func (c *Cluster) imageFill(id int, image *api.Image, create, expire, used, upload *time.Time, arch int) error {
// Some of the dates can be nil in the DB, let's process them.
if create != nil {
image.CreatedAt = *create
} else {
image.CreatedAt = time.Time{}
}
if expire != nil {
image.ExpiresAt = *expire
... | go | {
"resource": ""
} |
q176545 | ImageLocate | test | func (c *Cluster) ImageLocate(fingerprint string) (string, error) {
stmt := `
SELECT nodes.address FROM nodes
LEFT JOIN images_nodes ON images_nodes.node_id = nodes.id
LEFT JOIN images ON images_nodes.image_id = images.id
WHERE images.fingerprint = ?
`
var localAddress string // Address of this node
var addresse... | go | {
"resource": ""
} |
q176546 | ImageAssociateNode | test | func (c *Cluster) ImageAssociateNode(project, fingerprint string) error {
imageID, _, err := c.ImageGet(project, fingerprint, false, true)
if err != nil {
return err
}
err = c.Transaction(func(tx *ClusterTx) error {
_, err := tx.tx.Exec("INSERT INTO images_nodes(image_id, node_id) VALUES(?, ?)", imageID, c.nod... | go | {
"resource": ""
} |
q176547 | ImageDelete | test | func (c *Cluster) ImageDelete(id int) error {
err := exec(c.db, "DELETE FROM images WHERE id=?", id)
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q176548 | ImageAliasesGet | test | func (c *Cluster) ImageAliasesGet(project string) ([]string, error) {
err := c.Transaction(func(tx *ClusterTx) error {
enabled, err := tx.ProjectHasImages(project)
if err != nil {
return errors.Wrap(err, "Check if project has images")
}
if !enabled {
project = "default"
}
return nil
})
if err != ni... | go | {
"resource": ""
} |
q176549 | ImageAliasGet | test | func (c *Cluster) ImageAliasGet(project, name string, isTrustedClient bool) (int, api.ImageAliasesEntry, error) {
id := -1
entry := api.ImageAliasesEntry{}
err := c.Transaction(func(tx *ClusterTx) error {
enabled, err := tx.ProjectHasImages(project)
if err != nil {
return errors.Wrap(err, "Check if project h... | go | {
"resource": ""
} |
q176550 | ImageAliasRename | test | func (c *Cluster) ImageAliasRename(id int, name string) error {
err := exec(c.db, "UPDATE images_aliases SET name=? WHERE id=?", name, id)
return err
} | go | {
"resource": ""
} |
q176551 | ImageAliasDelete | test | func (c *Cluster) ImageAliasDelete(project, name string) error {
err := c.Transaction(func(tx *ClusterTx) error {
enabled, err := tx.ProjectHasImages(project)
if err != nil {
return errors.Wrap(err, "Check if project has images")
}
if !enabled {
project = "default"
}
return nil
})
if err != nil {
... | go | {
"resource": ""
} |
q176552 | ImageAliasesMove | test | func (c *Cluster) ImageAliasesMove(source int, destination int) error {
err := exec(c.db, "UPDATE images_aliases SET image_id=? WHERE image_id=?", destination, source)
return err
} | go | {
"resource": ""
} |
q176553 | ImageAliasAdd | test | func (c *Cluster) ImageAliasAdd(project, name string, imageID int, desc string) error {
err := c.Transaction(func(tx *ClusterTx) error {
enabled, err := tx.ProjectHasImages(project)
if err != nil {
return errors.Wrap(err, "Check if project has images")
}
if !enabled {
project = "default"
}
return nil... | go | {
"resource": ""
} |
q176554 | ImageAliasUpdate | test | func (c *Cluster) ImageAliasUpdate(id int, imageID int, desc string) error {
stmt := `UPDATE images_aliases SET image_id=?, description=? WHERE id=?`
err := exec(c.db, stmt, imageID, desc, id)
return err
} | go | {
"resource": ""
} |
q176555 | ImageLastAccessUpdate | test | func (c *Cluster) ImageLastAccessUpdate(fingerprint string, date time.Time) error {
stmt := `UPDATE images SET last_use_date=? WHERE fingerprint=?`
err := exec(c.db, stmt, date, fingerprint)
return err
} | go | {
"resource": ""
} |
q176556 | ImageLastAccessInit | test | func (c *Cluster) ImageLastAccessInit(fingerprint string) error {
stmt := `UPDATE images SET cached=1, last_use_date=strftime("%s") WHERE fingerprint=?`
err := exec(c.db, stmt, fingerprint)
return err
} | go | {
"resource": ""
} |
q176557 | ImageUpdate | test | func (c *Cluster) ImageUpdate(id int, fname string, sz int64, public bool, autoUpdate bool, architecture string, createdAt time.Time, expiresAt time.Time, properties map[string]string) error {
arch, err := osarch.ArchitectureId(architecture)
if err != nil {
arch = 0
}
err = c.Transaction(func(tx *ClusterTx) erro... | go | {
"resource": ""
} |
q176558 | ImageInsert | test | func (c *Cluster) ImageInsert(project, fp string, fname string, sz int64, public bool, autoUpdate bool, architecture string, createdAt time.Time, expiresAt time.Time, properties map[string]string) error {
err := c.Transaction(func(tx *ClusterTx) error {
enabled, err := tx.ProjectHasImages(project)
if err != nil {
... | go | {
"resource": ""
} |
q176559 | ImageGetPools | test | func (c *Cluster) ImageGetPools(imageFingerprint string) ([]int64, error) {
poolID := int64(-1)
query := "SELECT storage_pool_id FROM storage_volumes WHERE node_id=? AND name=? AND type=?"
inargs := []interface{}{c.nodeID, imageFingerprint, StoragePoolVolumeTypeImage}
outargs := []interface{}{poolID}
result, err ... | go | {
"resource": ""
} |
q176560 | ImageGetPoolNamesFromIDs | test | func (c *Cluster) ImageGetPoolNamesFromIDs(poolIDs []int64) ([]string, error) {
var poolName string
query := "SELECT name FROM storage_pools WHERE id=?"
poolNames := []string{}
for _, poolID := range poolIDs {
inargs := []interface{}{poolID}
outargs := []interface{}{poolName}
result, err := queryScan(c.db, ... | go | {
"resource": ""
} |
q176561 | ImageUploadedAt | test | func (c *Cluster) ImageUploadedAt(id int, uploadedAt time.Time) error {
err := exec(c.db, "UPDATE images SET upload_date=? WHERE id=?", uploadedAt, id)
return err
} | go | {
"resource": ""
} |
q176562 | ImagesGetOnCurrentNode | test | func (c *Cluster) ImagesGetOnCurrentNode() (map[string][]string, error) {
return c.ImagesGetByNodeID(c.nodeID)
} | go | {
"resource": ""
} |
q176563 | ImagesGetByNodeID | test | func (c *Cluster) ImagesGetByNodeID(id int64) (map[string][]string, error) {
images := make(map[string][]string) // key is fingerprint, value is list of projects
err := c.Transaction(func(tx *ClusterTx) error {
stmt := `
SELECT images.fingerprint, projects.name FROM images
LEFT JOIN images_nodes ON images... | go | {
"resource": ""
} |
q176564 | ImageGetNodesWithImage | test | func (c *Cluster) ImageGetNodesWithImage(fingerprint string) ([]string, error) {
q := `
SELECT DISTINCT nodes.address FROM nodes
LEFT JOIN images_nodes ON images_nodes.node_id = nodes.id
LEFT JOIN images ON images_nodes.image_id = images.id
WHERE images.fingerprint = ?
`
return c.getNodesByImageFingerprint(q, fi... | go | {
"resource": ""
} |
q176565 | ImageGetNodesWithoutImage | test | func (c *Cluster) ImageGetNodesWithoutImage(fingerprint string) ([]string, error) {
q := `
SELECT DISTINCT nodes.address FROM nodes WHERE nodes.address NOT IN (
SELECT DISTINCT nodes.address FROM nodes
LEFT JOIN images_nodes ON images_nodes.node_id = nodes.id
LEFT JOIN images ON images_nodes.image_id = image... | go | {
"resource": ""
} |
q176566 | Add | test | func (g *Group) Add(f Func, schedule Schedule) *Task {
i := len(g.tasks)
g.tasks = append(g.tasks, Task{
f: f,
schedule: schedule,
reset: make(chan struct{}, 16), // Buffered to not block senders
})
return &g.tasks[i]
} | go | {
"resource": ""
} |
q176567 | Start | test | func (g *Group) Start() {
ctx := context.Background()
ctx, g.cancel = context.WithCancel(ctx)
g.wg.Add(len(g.tasks))
g.mu.Lock()
if g.running == nil {
g.running = make(map[int]bool)
}
g.mu.Unlock()
for i := range g.tasks {
g.mu.Lock()
if g.running[i] {
g.mu.Unlock()
continue
}
g.running[i] = ... | go | {
"resource": ""
} |
q176568 | zfsIsEnabled | test | func zfsIsEnabled() bool {
out, err := exec.LookPath("zfs")
if err != nil || len(out) == 0 {
return false
}
return true
} | go | {
"resource": ""
} |
q176569 | zfsToolVersionGet | test | func zfsToolVersionGet() (string, error) {
// This function is only really ever relevant on Ubuntu as the only
// distro that ships out of sync tools and kernel modules
out, err := shared.RunCommand("dpkg-query", "--showformat=${Version}", "--show", "zfsutils-linux")
if err != nil {
return "", err
}
return str... | go | {
"resource": ""
} |
q176570 | zfsModuleVersionGet | test | func zfsModuleVersionGet() (string, error) {
var zfsVersion string
if shared.PathExists("/sys/module/zfs/version") {
out, err := ioutil.ReadFile("/sys/module/zfs/version")
if err != nil {
return "", fmt.Errorf("Could not determine ZFS module version")
}
zfsVersion = string(out)
} else {
out, err := sh... | go | {
"resource": ""
} |
q176571 | zfsPoolVolumeCreate | test | func zfsPoolVolumeCreate(dataset string, properties ...string) (string, error) {
cmd := []string{"zfs", "create"}
for _, prop := range properties {
cmd = append(cmd, []string{"-o", prop}...)
}
cmd = append(cmd, []string{"-p", dataset}...)
return shared.RunCommand(cmd[0], cmd[1:]...)
} | go | {
"resource": ""
} |
q176572 | zfsPoolVolumeExists | test | func zfsPoolVolumeExists(dataset string) (bool, error) {
output, err := shared.RunCommand(
"zfs", "list", "-Ho", "name")
if err != nil {
return false, err
}
for _, name := range strings.Split(output, "\n") {
if name == dataset {
return true, nil
}
}
return false, nil
} | go | {
"resource": ""
} |
q176573 | NetworkIDsNotPending | test | func (c *ClusterTx) NetworkIDsNotPending() (map[string]int64, error) {
networks := []struct {
id int64
name string
}{}
dest := func(i int) []interface{} {
networks = append(networks, struct {
id int64
name string
}{})
return []interface{}{&networks[i].id, &networks[i].name}
}
stmt, err := c.tx... | go | {
"resource": ""
} |
q176574 | NetworkConfigAdd | test | func (c *ClusterTx) NetworkConfigAdd(networkID, nodeID int64, config map[string]string) error {
return networkConfigAdd(c.tx, networkID, nodeID, config)
} | go | {
"resource": ""
} |
q176575 | NetworkNodeJoin | test | func (c *ClusterTx) NetworkNodeJoin(networkID, nodeID int64) error {
columns := []string{"network_id", "node_id"}
values := []interface{}{networkID, nodeID}
_, err := query.UpsertObject(c.tx, "networks_nodes", columns, values)
return err
} | go | {
"resource": ""
} |
q176576 | NetworkCreatePending | test | func (c *ClusterTx) NetworkCreatePending(node, name string, conf map[string]string) error {
// First check if a network with the given name exists, and, if
// so, that it's in the pending state.
network := struct {
id int64
state int
}{}
var errConsistency error
dest := func(i int) []interface{} {
// Sa... | go | {
"resource": ""
} |
q176577 | NetworkCreated | test | func (c *ClusterTx) NetworkCreated(name string) error {
return c.networkState(name, networkCreated)
} | go | {
"resource": ""
} |
q176578 | NetworkErrored | test | func (c *ClusterTx) NetworkErrored(name string) error {
return c.networkState(name, networkErrored)
} | go | {
"resource": ""
} |
q176579 | NetworkGet | test | func (c *Cluster) NetworkGet(name string) (int64, *api.Network, error) {
description := sql.NullString{}
id := int64(-1)
state := 0
q := "SELECT id, description, state FROM networks WHERE name=?"
arg1 := []interface{}{name}
arg2 := []interface{}{&id, &description, &state}
err := dbQueryRowScan(c.db, q, arg1, ar... | go | {
"resource": ""
} |
q176580 | networkNodes | test | func (c *Cluster) networkNodes(networkID int64) ([]string, error) {
stmt := `
SELECT nodes.name FROM nodes
JOIN networks_nodes ON networks_nodes.node_id = nodes.id
WHERE networks_nodes.network_id = ?
`
var nodes []string
err := c.Transaction(func(tx *ClusterTx) error {
var err error
nodes, err = query.Select... | go | {
"resource": ""
} |
q176581 | NetworkGetInterface | test | func (c *Cluster) NetworkGetInterface(devName string) (int64, *api.Network, error) {
id := int64(-1)
name := ""
value := ""
q := "SELECT networks.id, networks.name, networks_config.value FROM networks LEFT JOIN networks_config ON networks.id=networks_config.network_id WHERE networks_config.key=\"bridge.external_in... | go | {
"resource": ""
} |
q176582 | NetworkConfigGet | test | func (c *Cluster) NetworkConfigGet(id int64) (map[string]string, error) {
var key, value string
query := `
SELECT
key, value
FROM networks_config
WHERE network_id=?
AND (node_id=? OR node_id IS NULL)`
inargs := []interface{}{id, c.nodeID}
outfmt := []interface{}{key, va... | go | {
"resource": ""
} |
q176583 | NetworkCreate | test | func (c *Cluster) NetworkCreate(name, description string, config map[string]string) (int64, error) {
var id int64
err := c.Transaction(func(tx *ClusterTx) error {
result, err := tx.tx.Exec("INSERT INTO networks (name, description, state) VALUES (?, ?, ?)", name, description, networkCreated)
if err != nil {
ret... | go | {
"resource": ""
} |
q176584 | NetworkUpdate | test | func (c *Cluster) NetworkUpdate(name, description string, config map[string]string) error {
id, _, err := c.NetworkGet(name)
if err != nil {
return err
}
err = c.Transaction(func(tx *ClusterTx) error {
err = NetworkUpdateDescription(tx.tx, id, description)
if err != nil {
return err
}
err = NetworkCo... | go | {
"resource": ""
} |
q176585 | NetworkUpdateDescription | test | func NetworkUpdateDescription(tx *sql.Tx, id int64, description string) error {
_, err := tx.Exec("UPDATE networks SET description=? WHERE id=?", description, id)
return err
} | go | {
"resource": ""
} |
q176586 | NetworkConfigClear | test | func NetworkConfigClear(tx *sql.Tx, networkID, nodeID int64) error {
_, err := tx.Exec(
"DELETE FROM networks_config WHERE network_id=? AND (node_id=? OR node_id IS NULL)",
networkID, nodeID)
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q176587 | NetworkDelete | test | func (c *Cluster) NetworkDelete(name string) error {
id, _, err := c.NetworkGet(name)
if err != nil {
return err
}
err = exec(c.db, "DELETE FROM networks WHERE id=?", id)
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q176588 | NetworkRename | test | func (c *Cluster) NetworkRename(oldName string, newName string) error {
id, _, err := c.NetworkGet(oldName)
if err != nil {
return err
}
err = c.Transaction(func(tx *ClusterTx) error {
_, err = tx.tx.Exec("UPDATE networks SET name=? WHERE id=?", newName, id)
return err
})
return err
} | go | {
"resource": ""
} |
q176589 | GetContainers | test | func (r *ProtocolLXD) GetContainers() ([]api.Container, error) {
containers := []api.Container{}
// Fetch the raw value
_, err := r.queryStruct("GET", "/containers?recursion=1", nil, "", &containers)
if err != nil {
return nil, err
}
return containers, nil
} | go | {
"resource": ""
} |
q176590 | GetContainersFull | test | func (r *ProtocolLXD) GetContainersFull() ([]api.ContainerFull, error) {
containers := []api.ContainerFull{}
if !r.HasExtension("container_full") {
return nil, fmt.Errorf("The server is missing the required \"container_full\" API extension")
}
// Fetch the raw value
_, err := r.queryStruct("GET", "/containers?... | go | {
"resource": ""
} |
q176591 | GetContainer | test | func (r *ProtocolLXD) GetContainer(name string) (*api.Container, string, error) {
container := api.Container{}
// Fetch the raw value
etag, err := r.queryStruct("GET", fmt.Sprintf("/containers/%s", url.QueryEscape(name)), nil, "", &container)
if err != nil {
return nil, "", err
}
return &container, etag, nil
... | go | {
"resource": ""
} |
q176592 | CreateContainerFromBackup | test | func (r *ProtocolLXD) CreateContainerFromBackup(args ContainerBackupArgs) (Operation, error) {
if !r.HasExtension("container_backup") {
return nil, fmt.Errorf("The server is missing the required \"container_backup\" API extension")
}
if args.PoolName == "" {
// Send the request
op, _, err := r.queryOperation(... | go | {
"resource": ""
} |
q176593 | CreateContainer | test | func (r *ProtocolLXD) CreateContainer(container api.ContainersPost) (Operation, error) {
if container.Source.ContainerOnly {
if !r.HasExtension("container_only_migration") {
return nil, fmt.Errorf("The server is missing the required \"container_only_migration\" API extension")
}
}
// Send the request
op, _,... | go | {
"resource": ""
} |
q176594 | CreateContainerFromImage | test | func (r *ProtocolLXD) CreateContainerFromImage(source ImageServer, image api.Image, req api.ContainersPost) (RemoteOperation, error) {
// Set the minimal source fields
req.Source.Type = "image"
// Optimization for the local image case
if r == source {
// Always use fingerprints for local case
req.Source.Finger... | go | {
"resource": ""
} |
q176595 | UpdateContainer | test | func (r *ProtocolLXD) UpdateContainer(name string, container api.ContainerPut, ETag string) (Operation, error) {
// Send the request
op, _, err := r.queryOperation("PUT", fmt.Sprintf("/containers/%s", url.QueryEscape(name)), container, ETag)
if err != nil {
return nil, err
}
return op, nil
} | go | {
"resource": ""
} |
q176596 | RenameContainer | test | func (r *ProtocolLXD) RenameContainer(name string, container api.ContainerPost) (Operation, error) {
// Sanity check
if container.Migration {
return nil, fmt.Errorf("Can't ask for a migration through RenameContainer")
}
// Send the request
op, _, err := r.queryOperation("POST", fmt.Sprintf("/containers/%s", url... | go | {
"resource": ""
} |
q176597 | ExecContainer | test | func (r *ProtocolLXD) ExecContainer(containerName string, exec api.ContainerExecPost, args *ContainerExecArgs) (Operation, error) {
if exec.RecordOutput {
if !r.HasExtension("container_exec_recording") {
return nil, fmt.Errorf("The server is missing the required \"container_exec_recording\" API extension")
}
}... | go | {
"resource": ""
} |
q176598 | GetContainerFile | test | func (r *ProtocolLXD) GetContainerFile(containerName string, path string) (io.ReadCloser, *ContainerFileResponse, error) {
// Prepare the HTTP request
requestURL, err := shared.URLEncode(
fmt.Sprintf("%s/1.0/containers/%s/files", r.httpHost, url.QueryEscape(containerName)),
map[string]string{"path": path})
if er... | go | {
"resource": ""
} |
q176599 | CreateContainerFile | test | func (r *ProtocolLXD) CreateContainerFile(containerName string, path string, args ContainerFileArgs) error {
if args.Type == "directory" {
if !r.HasExtension("directory_manipulation") {
return fmt.Errorf("The server is missing the required \"directory_manipulation\" API extension")
}
}
if args.Type == "symli... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.