id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c25500 | _, err = rf.Write(right)
if err != nil {
return err
}
rf.Close()
cmd := exec.Command("/usr/bin/diff", "-u", lf.Name(), rf.Name())
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
cmd.Run()
return nil
} | |
c25501 | ptable, JobController: jobController}
discoverer, err := discovery.NewDiscoverer(runtimeConfig, cleanupTracker)
if err != nil {
glog.Fatalf("Error initializing discoverer: %v", err)
}
deleter := deleter.NewDeleter(runtimeConfig, cleanupTracker)
// Start informers after all event listeners are registered.
ru... | |
c25502 | return newFlexProvisionerInternal(client, execCommand, flexDriver)
} | |
c25503 | }
dsw.Lock()
defer dsw.Unlock()
snapshotName := MakeSnapshotName(snapshot)
glog.Infof("Adding new snapshot to desired state of world: %s", snapshotName)
dsw.snapshots[snapshotName] = snapshot
return nil
} | |
c25504 |
glog.Infof("Deleting snapshot from desired state of world: %s", snapshotName)
delete(dsw.snapshots, snapshotName)
return nil
} | |
c25505 |
glog.Fatalf("Error creating xfs quotaer! %v", err)
}
} else {
quotaer = newDummyQuotaer()
}
return newNFSProvisionerInternal(exportDir, client, outOfCluster, exp, quotaer, serverHostname, maxExports, exportSubnet)
} | |
c25506 | reached we're ok to provision
ok := p.checkExportLimit()
if !ok {
glog.Infof("export limit reached. skipping claim %s/%s", claim.Namespace, claim.Name)
}
return ok
} | |
c25507 | return fmt.Errorf("strconv.ParseUint failed with error: %v", err)
}
cmd := exec.Command("chgrp", strconv.FormatUint(groupID, 10), path)
out, err := cmd.CombinedOutput()
if err != nil {
os.RemoveAll(path)
return fmt.Errorf("chgrp failed with error: %v, output: %s", err, out)
}
}
return nil
} | |
c25508 | err != nil {
return "", 0, fmt.Errorf("error adding export block for path %s: %v", path, err)
}
err = p.exporter.Export(path)
if err != nil {
p.exporter.RemoveExportBlock(block, exportID)
return "", 0, fmt.Errorf("error exporting export block %s: %v", block, err)
}
return block, exportID, nil
} | |
c25509 | %v", path, err)
}
err = p.quotaer.SetQuota(projectID, path, limit)
if err != nil {
p.quotaer.RemoveProject(block, projectID)
return "", 0, fmt.Errorf("error setting quota for path %s: %v", path, err)
}
return block, projectID, nil
} | |
c25510 | *Deleter {
return &Deleter{
RuntimeConfig: config,
CleanupStatus: cleanupTracker,
}
} | |
c25511 |
deleteType = metrics.DeleteTypeJob
}
metrics.PersistentVolumeDeleteFailedTotal.WithLabelValues(string(mode), deleteType).Inc()
cleaningLocalPVErr := fmt.Errorf("Error cleaning PV %q: %v", name, err.Error())
d.RuntimeConfig.Recorder.Eventf(pv, v1.EventTypeWarning, common.EventVolumeFailedDelete, cl... | |
c25512 | {
if isJob {
return c.JobController.IsCleaningJobRunning(pvName)
}
return c.ProcTable.IsRunning(pvName)
} | |
c25513 | return c.JobController.RemoveJob(pvName)
}
return c.ProcTable.RemoveEntry(pvName)
} | |
c25514 | client,
identity: id,
allocator: gidallocator.New(client),
}
} | |
c25515 | v.mutex.RUnlock()
return len(v.procTable) == 0
} | |
c25516 | return v.markStatus(pvName, CSFailed)
} | |
c25517 | return v.markStatus(pvName, CSSucceeded)
} | |
c25518 | pvName)
}
if entry.Status == CSUnknown {
return CSUnknown, nil, fmt.Errorf("proctable entry for %q in unexpected unknown state", pvName)
}
delete(v.procTable, pvName)
return entry.Status, &entry.StartTime, nil
} | |
c25519 |
}
return ProcTableStats{
Running: running,
Succeeded: v.succeeded,
Failed: v.failed,
}
} | |
c25520 |
return f.realTable.MarkFailed(pvName)
} | |
c25521 |
return f.realTable.MarkSucceeded(pvName)
} | |
c25522 | f.RemoveCount++
return f.realTable.RemoveEntry(pvName)
} | |
c25523 | runtime.ContentTypeJSON
config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: serializer.NewCodecFactory(scheme)}
client, err := rest.RESTClientFor(&config)
if err != nil {
return nil, nil, err
}
return client, scheme, nil
} | |
c25524 | Name: crdv1.VolumeSnapshotResourcePlural + "." + crdv1.GroupName,
},
Spec: apiextensionsv1beta1.CustomResourceDefinitionSpec{
Group: crdv1.GroupName,
Version: crdv1.SchemeGroupVersion.Version,
Scope: apiextensionsv1beta1.NamespaceScoped,
Names: apiextensionsv1beta1.CustomResourceDefinitionNames{
... | |
c25525 | _, err := snapshotClient.Get().
Resource(crdv1.VolumeSnapshotDataResourcePlural).DoRaw()
if err == nil {
return true, nil
}
if apierrors.IsNotFound(err) {
return false, nil
}
return false, err
})
} | |
c25526 | range sList {
ret = append(ret, mapServerToNodeName(&sList[i]))
}
return true, nil
})
if err != nil {
return nil, err
}
glog.V(3).Infof("Found %v instances matching %v: %v",
len(ret), nameFilter, ret)
return ret, nil
} | |
c25527 |
addrs, err := getAddressesByName(i.compute, name)
if err != nil {
return nil, err
}
glog.V(4).Infof("NodeAddresses(%v) => %v", name, addrs)
return addrs, nil
} | |
c25528 | for ; id <= math.MaxUint16; id++ {
if _, ok := ids[id]; !ok {
break
}
}
ids[id] = true
mutex.Unlock()
return id
} | |
c25529 | re.String(), digitsRe)
}
read, err := ioutil.ReadFile(config)
if err != nil {
return ids, err
}
allMatches := re.FindAllSubmatch(read, -1)
for _, match := range allMatches {
digits := match[1]
if id, err := strconv.ParseUint(string(digits), 10, 16); err == nil {
ids[uint16(id)] = true
}
}
return ... | |
c25530 | // sc.recorder = eventBroadcaster.NewRecorder(api.Scheme, apiv1.EventSource{Component: "volume snapshotting"})
sc.desiredStateOfWorld = cache.NewDesiredStateOfWorld()
sc.actualStateOfWorld = cache.NewActualStateOfWorld()
sc.snapshotter = snapshotter.NewVolumeSnapshotter(
client,
scheme,
clientset,
sc.actu... | |
c25531 | ctx, c.snapshotController.HasSynced) {
return
}
go c.reconciler.Run(ctx)
go c.desiredStateOfWorldPopulator.Run(ctx)
} | |
c25532 | port for %q (no valid listeners)", name)
}
if expectedTarget == orEmpty(actual.Target) &&
expectedHealthyThreshold == orZero(actual.HealthyThreshold) &&
expectedUnhealthyThreshold == orZero(actual.UnhealthyThreshold) &&
expectedTimeout == orZero(actual.Timeout) &&
expectedInterval == orZero(actual.Interval)... | |
c25533 | provided, it results in empty string
// which disable all RBD image format 2 features as we expected
features := strings.Join(pOpts.imageFeatures, ",")
args = append(args, "--image-feature", features)
}
output, err = u.execCommand("rbd", args)
if err != nil {
klog.Warningf("failed to create rbd image, outpu... | |
c25534 | pOpts.pool, pOpts.adminID, pOpts.adminSecret)
args := []string{"status", image, "--pool", pOpts.pool, "-m", mon, "--id", pOpts.adminID, "--key=" + pOpts.adminSecret}
cmd, err = u.execCommand("rbd", args)
output = string(cmd)
// If command never succeed, returns its last error.
if err != nil {
return false, err... | |
c25535 | pOpts.adminID, pOpts.adminSecret)
args := []string{"rm", image, "--pool", pOpts.pool, "--id", pOpts.adminID, "-m", mon, "--key=" + pOpts.adminSecret}
output, err = u.execCommand("rbd", args)
if err == nil {
return nil
}
klog.Errorf("failed to delete rbd image: %v, command output: %s", err, string(output))
retu... | |
c25536 |
_, err = c.ec2.DeleteRoute(request)
if err != nil {
return fmt.Errorf("error deleting AWS route (%s): %v", route.DestinationCIDR, err)
}
return nil
} | |
c25537 | config,
Labels: labelMap,
CleanupTracker: cleanupTracker,
classLister: sharedInformer.Lister(),
nodeAffinityAnn: tmpAnnotations[common.AlphaStorageNodeAffinityAnnotation]}, nil
}
volumeNodeAffinity, err := generateVolumeNodeAffinity(config.Node)
if err != nil {
return nil, fmt.Errorf(... | |
c25538 | config := range d.DiscoveryMap {
d.discoverVolumesAtPath(class, config)
}
} | |
c25539 | // Round down the capacity to the nearest unit.
size := capacityBytes / easyToReadUnitBytes
if size >= 10 {
return size * easyToReadUnitBytes
}
}
return capacityBytes
} | |
c25540 | err := json.Unmarshal([]byte(annotations[common.AlphaStorageNodeAffinityAnnotation]), &affinity)
if err != nil {
return nil, err
}
return &affinity, nil
}
return nil, nil
} | |
c25541 | != nil {
return err
}
annotations[common.AlphaStorageNodeAffinityAnnotation] = string(json)
return nil
} | |
c25542 |
networkURL = gceNetworkURL(cfg.Global.ProjectID, cfg.Global.NetworkName)
}
}
if cfg.Global.TokenURL != "" {
tokenSource = NewAltTokenSource(cfg.Global.TokenURL, cfg.Global.TokenBody)
}
nodeTags = cfg.Global.NodeTags
nodeInstancePrefix = cfg.Global.NodeInstancePrefix
if cfg.Global.Multizone {
m... | |
c25543 | default:
glog.Errorf("Unexpected affinity type: %v", affinityType)
return gceAffinityTypeNone
}
} | |
c25544 | return err
}
return gce.deleteForwardingRule(name, region)
} | |
c25545 | nil {
return err
}
return gce.deleteTargetPool(name, region, hc)
} | |
c25546 | if UDP ports are required. This means the method signature will change,
// forcing downstream clients to refactor interfaces.
for _, p := range ports {
svcPorts = append(svcPorts, v1.ServicePort{Port: int32(p), Protocol: v1.ProtocolTCP})
}
hosts, err := gce.getInstancesByNames(hostNames)
if err != nil {
retur... | |
c25547 | name).Do()
if err != nil {
return err
}
return gce.waitForGlobalOp(op)
} | |
c25548 | return gce.service.GlobalAddresses.Get(gce.projectID, name).Do()
} | |
c25549 | gce.service.UrlMaps.Get(gce.projectID, name).Do()
} | |
c25550 |
}
op, err := gce.service.UrlMaps.Insert(gce.projectID, urlMap).Do()
if err != nil {
return nil, err
}
if err = gce.waitForGlobalOp(op); err != nil {
return nil, err
}
return gce.GetURLMap(name)
} | |
c25551 | = gce.waitForGlobalOp(op); err != nil {
return nil, err
}
return gce.service.UrlMaps.Get(gce.projectID, urlMap.Name).Do()
} | |
c25552 | 500
return gce.service.UrlMaps.List(gce.projectID).Do()
} | |
c25553 | gce.service.TargetHttpProxies.Get(gce.projectID, name).Do()
} | |
c25554 | return nil, err
}
if err = gce.waitForGlobalOp(op); err != nil {
return nil, err
}
return gce.GetTargetHTTPProxy(name)
} | |
c25555 | proxy.Name, &compute.UrlMapReference{UrlMap: urlMap.SelfLink}).Do()
if err != nil {
return err
}
return gce.waitForGlobalOp(op)
} | |
c25556 | the first 500
return gce.service.TargetHttpProxies.List(gce.projectID).Do()
} | |
c25557 | gce.service.TargetHttpsProxies.Get(gce.projectID, name).Do()
} | |
c25558 | }
op, err := gce.service.TargetHttpsProxies.Insert(gce.projectID, proxy).Do()
if err != nil {
return nil, err
}
if err = gce.waitForGlobalOp(op); err != nil {
return nil, err
}
return gce.GetTargetHTTPSProxy(name)
} | |
c25559 | proxy.Name, &compute.UrlMapReference{UrlMap: urlMap.SelfLink}).Do()
if err != nil {
return err
}
return gce.waitForGlobalOp(op)
} | |
c25560 | proxy.Name, &compute.TargetHttpsProxiesSetSslCertificatesRequest{SslCertificates: []string{sslCert.SelfLink}}).Do()
if err != nil {
return err
}
return gce.waitForGlobalOp(op)
} | |
c25561 | if isHTTPErrorCode(err, http.StatusNotFound) {
return nil
}
return err
}
return gce.waitForGlobalOp(op)
} | |
c25562 | just the first 500
return gce.service.TargetHttpsProxies.List(gce.projectID).Do()
} | |
c25563 | gce.service.SslCertificates.Get(gce.projectID, name).Do()
} | |
c25564 | gce.service.BackendServices.Get(gce.projectID, name).Do()
} | |
c25565 |
if err != nil {
return err
}
return gce.waitForGlobalOp(op)
} | |
c25566 | gce.service.BackendServices.Insert(gce.projectID, bg).Do()
if err != nil {
return err
}
return gce.waitForGlobalOp(op)
} | |
c25567 | first 500
return gce.service.BackendServices.List(gce.projectID).Do()
} | |
c25568 | {
groupRef := &compute.ResourceGroupReference{Group: instanceGroupLink}
return gce.service.BackendServices.GetHealth(gce.projectID, name, groupRef).Do()
} | |
c25569 | gce.service.HttpHealthChecks.Get(gce.projectID, name).Do()
} | |
c25570 | hc.Name, hc).Do()
if err != nil {
return err
}
return gce.waitForGlobalOp(op)
} | |
c25571 | gce.service.HttpHealthChecks.Insert(gce.projectID, hc).Do()
if err != nil {
return err
}
return gce.waitForGlobalOp(op)
} | |
c25572 | the first 500
return gce.service.HttpHealthChecks.List(gce.projectID).Do()
} | |
c25573 | }
if err = gce.waitForZoneOp(op, zone); err != nil {
return nil, err
}
return gce.GetInstanceGroup(name, zone)
} | |
c25574 | gce.projectID, zone, name,
&compute.InstanceGroupsRemoveInstancesRequest{
Instances: instances,
}).Do()
if err != nil {
if isHTTPErrorCode(err, http.StatusNotFound) {
return nil
}
return err
}
return gce.waitForZoneOp(op, zone)
} | |
c25575 | entire zone URL.
zoneURLParts := strings.Split(ig.Zone, "/")
zone := zoneURLParts[len(zoneURLParts)-1]
op, err := gce.service.InstanceGroups.SetNamedPorts(
gce.projectID, zone, ig.Name,
&compute.InstanceGroupsSetNamedPortsRequest{
NamedPorts: ig.NamedPorts}).Do()
if err != nil {
return nil, err
}
if er... | |
c25576 | return types.NodeName(hostname), nil
} | |
c25577 | generally can't guarantee correct
// volume spreading if the set of zones is changing
// (and volume spreading is currently only a heuristic).
// Long term we want to replace GetAllZones (which primarily supports volume
// spreading) with a scheduler policy that is able to see the global state of
// volumes ... | |
c25578 | name doesn't start with <clusterName>
if !strings.HasPrefix(r.Name, prefix) {
continue
}
target := path.Base(r.NextHopInstance)
// TODO: Should we lastComponent(target) this?
targetNodeName := types.NodeName(target) // NodeName == Instance Name on GCE
routes = append(routes, &cloudprovider.Route... | |
c25579 | gce.localZone,
Region: gce.region,
}, nil
} | |
c25580 | return volume.NewDeletedVolumeInUseError(err.Error())
}
if err == cloudprovider.ErrDiskNotFound {
return nil
}
return err
} | |
c25581 | := gce.convertDiskToAttachedDisk(disk, readWrite)
attachOp, err := gce.service.Instances.AttachDisk(gce.projectID, disk.Zone, instance.Name, attachedDisk).Do()
if err != nil {
return err
}
return gce.waitForZoneOp(attachOp, disk.Zone)
} | |
c25582 | devicePath)
return nil
}
return fmt.Errorf("error getting instance %q", instanceName)
}
detachOp, err := gce.service.Instances.DetachDisk(gce.projectID, inst.Zone, inst.Name, devicePath).Do()
if err != nil {
return err
}
return gce.waitForZoneOp(detachOp, inst.Zone)
} | |
c25583 | instanceName,
diskName)
return false, nil
}
return false, err
}
for _, disk := range instance.Disks {
if disk.DeviceName == diskName {
// Disk is still attached to node
return true, nil
}
}
return false, nil
} | |
c25584 | non-nil.
if disk == nil {
continue
}
if found != nil {
return nil, fmt.Errorf("GCE persistent disk name was found in multiple zones: %q", diskName)
}
found = disk
}
if found != nil {
return found, nil
}
glog.Warningf("GCE persistent disk %q not found in managed zones (%s)", diskName, strings.Join... | |
c25585 | readWrite,
Source: "https://" + path.Join("www.googleapis.com/compute/v1/projects/", gce.projectID, "zones", disk.Zone, "disks", disk.Name),
Type: "PERSISTENT",
}
} | |
c25586 | tagsStr,
Type: diskTypeURI,
SourceSnapshot: snapshotName,
}
glog.Infof("Create disk from snapshot diskToCreate %+v", diskToCreate)
createOp, err := gce.service.Disks.Insert(gce.projectID, zone, diskToCreate).Do()
glog.Infof("Create disk from snapshot operation %v, err %v", createOp, err)
if err !=... | |
c25587 | {
return "", false, fmt.Errorf("snapshot %s is not found", snapshotToGet)
}
if snapshot.Status == "READY" {
return snapshot.Status, true, nil
}
return snapshot.Status, false, nil
} | |
c25588 | var snapshotIDs, statuses []string
return snapshotIDs, statuses, nil
} | |
c25589 | }
deleteOp, err := gce.service.Snapshots.Delete(gce.projectID, snapshotToDelete).Do()
if err != nil {
return err
}
return gce.waitForGlobalOp(deleteOp)
} | |
c25590 | Description: tagsStr,
}
glog.V(4).Infof("Create snapshot project %s, zone %s, diskName %s, snapshotToCreate %+v", gce.projectID, zone, diskName, snapshotToCreate)
createOp, err := gce.service.Disks.CreateSnapshot(gce.projectID, zone, diskName, snapshotToCreate).Do()
glog.V(4).Infof("Create snapshot operation %v",... | |
c25591 | // TODO: Scoping? Do we need to qualify the cluster name?
allClusters = append(allClusters, clusters...)
}
return allClusters, nil
} | |
c25592 | name,
ID: i.Id,
Disks: i.Disks,
Type: lastComponent(i.MachineType),
}
instances[name] = instance
remaining--
}
}
if page >= maxPages {
glog.Errorf("getInstancesByNames exceeded maxPages=%d for Instances.List: truncating.", maxPages)
}
}
instanceArray := make([]*gceInstanc... | |
c25593 |
return nil, err
}
return &gceInstance{
Zone: lastComponent(res.Zone),
Name: res.Name,
ID: res.Id,
Disks: res.Disks,
Type: lastComponent(res.MachineType),
}, nil
}
return nil, cloudprovider.ErrInstanceNotFound
} | |
c25594 | {
a[name] = expr
} | |
c25595 | == 0 {
return
}
a[name] = expr
} | |
c25596 | nil && !info.IsDir() {
return true, path
}
}
return false, filepath.Join(pkgPath, "BUILD")
} | |
c25597 | }
if !RuleIsManaged(o) {
continue
}
reconcileAttr := func(o, n *bzl.Rule, name string) {
if e := n.Attr(name); e != nil {
o.SetAttr(name, e)
} else {
o.DelAttr(name)
}
}
for _, attr := range managedAttrs {
reconcileAttr(o, r, attr)
}
delete(oldRules, r.Name())
}
for _, r := ran... | |
c25598 |
automanaged = true
break
}
}
return automanaged
} | |
c25599 |
defer providersMutex.Unlock()
for name := range providers {
names = append(names, name)
}
return names
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.