_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q25500 | Diff | train | func Diff(left, right []byte) error {
lf, err := ioutil.TempFile("/tmp", "actual-file-")
if err != nil {
return err
}
defer lf.Close()
defer os.Remove(lf.Name())
rf, err := ioutil.TempFile("/tmp", "expected-file-")
if err != nil {
return err
}
defer rf.Close()
defer os.Remove(rf.Name())
_, err = lf.Wri... | go | {
"resource": ""
} |
q25501 | StartLocalController | train | func StartLocalController(client *kubernetes.Clientset, ptable deleter.ProcTable, config *common.UserConfig) {
glog.Info("Initializing volume cache\n")
var provisionerName string
if config.UseNodeNameOnly {
provisionerName = fmt.Sprintf("local-volume-provisioner-%v", config.Node.Name)
} else {
provisionerName ... | go | {
"resource": ""
} |
q25502 | NewFlexProvisioner | train | func NewFlexProvisioner(client kubernetes.Interface, execCommand string, flexDriver string) controller.Provisioner {
return newFlexProvisionerInternal(client, execCommand, flexDriver)
} | go | {
"resource": ""
} |
q25503 | AddSnapshot | train | func (dsw *desiredStateOfWorld) AddSnapshot(snapshot *crdv1.VolumeSnapshot) error {
if snapshot == nil {
return fmt.Errorf("nil snapshot spec")
}
dsw.Lock()
defer dsw.Unlock()
snapshotName := MakeSnapshotName(snapshot)
glog.Infof("Adding new snapshot to desired state of world: %s", snapshotName)
dsw.snapshot... | go | {
"resource": ""
} |
q25504 | DeleteSnapshot | train | func (dsw *desiredStateOfWorld) DeleteSnapshot(snapshotName string) error {
dsw.Lock()
defer dsw.Unlock()
glog.Infof("Deleting snapshot from desired state of world: %s", snapshotName)
delete(dsw.snapshots, snapshotName)
return nil
} | go | {
"resource": ""
} |
q25505 | NewNFSProvisioner | train | func NewNFSProvisioner(exportDir string, client kubernetes.Interface, outOfCluster bool, useGanesha bool, ganeshaConfig string, enableXfsQuota bool, serverHostname string, maxExports int, exportSubnet string) controller.Provisioner {
var exp exporter
if useGanesha {
exp = newGaneshaExporter(ganeshaConfig)
} else {... | go | {
"resource": ""
} |
q25506 | ShouldProvision | train | func (p *nfsProvisioner) ShouldProvision(claim *v1.PersistentVolumeClaim) bool {
// As long as the export limit has not been 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
} | go | {
"resource": ""
} |
q25507 | createDirectory | train | func (p *nfsProvisioner) createDirectory(directory, gid string) error {
// TODO quotas
path := path.Join(p.exportDir, directory)
if _, err := os.Stat(path); !os.IsNotExist(err) {
return fmt.Errorf("the path already exists")
}
perm := os.FileMode(0777 | os.ModeSetgid)
if gid != "none" {
// Execute permission ... | go | {
"resource": ""
} |
q25508 | createExport | train | func (p *nfsProvisioner) createExport(directory string, rootSquash bool) (string, uint16, error) {
path := path.Join(p.exportDir, directory)
block, exportID, err := p.exporter.AddExportBlock(path, rootSquash, p.exportSubnet)
if err != nil {
return "", 0, fmt.Errorf("error adding export block for path %s: %v", pat... | go | {
"resource": ""
} |
q25509 | createQuota | train | func (p *nfsProvisioner) createQuota(directory string, capacity resource.Quantity) (string, uint16, error) {
path := path.Join(p.exportDir, directory)
limit := strconv.FormatInt(capacity.Value(), 10)
block, projectID, err := p.quotaer.AddProject(path, limit)
if err != nil {
return "", 0, fmt.Errorf("error addin... | go | {
"resource": ""
} |
q25510 | NewDeleter | train | func NewDeleter(config *common.RuntimeConfig, cleanupTracker *CleanupStatusTracker) *Deleter {
return &Deleter{
RuntimeConfig: config,
CleanupStatus: cleanupTracker,
}
} | go | {
"resource": ""
} |
q25511 | DeletePVs | train | func (d *Deleter) DeletePVs() {
for _, pv := range d.Cache.ListPVs() {
if pv.Status.Phase != v1.VolumeReleased {
continue
}
name := pv.Name
switch pv.Spec.PersistentVolumeReclaimPolicy {
case v1.PersistentVolumeReclaimRetain:
glog.V(4).Infof("reclaimVolume[%s]: policy is Retain, nothing to do", name)
... | go | {
"resource": ""
} |
q25512 | InProgress | train | func (c *CleanupStatusTracker) InProgress(pvName string, isJob bool) bool {
if isJob {
return c.JobController.IsCleaningJobRunning(pvName)
}
return c.ProcTable.IsRunning(pvName)
} | go | {
"resource": ""
} |
q25513 | RemoveStatus | train | func (c *CleanupStatusTracker) RemoveStatus(pvName string, isJob bool) (CleanupState, *time.Time, error) {
if isJob {
return c.JobController.RemoveJob(pvName)
}
return c.ProcTable.RemoveEntry(pvName)
} | go | {
"resource": ""
} |
q25514 | NewglusterfileProvisioner | train | func NewglusterfileProvisioner(client kubernetes.Interface, id string) controller.Provisioner {
return &glusterfileProvisioner{
client: client,
identity: id,
allocator: gidallocator.New(client),
}
} | go | {
"resource": ""
} |
q25515 | IsEmpty | train | func (v *ProcTableImpl) IsEmpty() bool {
v.mutex.RLock()
defer v.mutex.RUnlock()
return len(v.procTable) == 0
} | go | {
"resource": ""
} |
q25516 | MarkFailed | train | func (v *ProcTableImpl) MarkFailed(pvName string) error {
return v.markStatus(pvName, CSFailed)
} | go | {
"resource": ""
} |
q25517 | MarkSucceeded | train | func (v *ProcTableImpl) MarkSucceeded(pvName string) error {
return v.markStatus(pvName, CSSucceeded)
} | go | {
"resource": ""
} |
q25518 | RemoveEntry | train | func (v *ProcTableImpl) RemoveEntry(pvName string) (CleanupState, *time.Time, error) {
v.mutex.Lock()
defer v.mutex.Unlock()
entry, ok := v.procTable[pvName]
if !ok {
return CSNotFound, nil, nil
}
if entry.Status == CSRunning {
return CSUnknown, nil, fmt.Errorf("cannot remove proctable entry for %q when it is... | go | {
"resource": ""
} |
q25519 | Stats | train | func (v *ProcTableImpl) Stats() ProcTableStats {
v.mutex.RLock()
defer v.mutex.RUnlock()
running := 0
for _, entry := range v.procTable {
if entry.Status == CSRunning {
running++
}
}
return ProcTableStats{
Running: running,
Succeeded: v.succeeded,
Failed: v.failed,
}
} | go | {
"resource": ""
} |
q25520 | MarkFailed | train | func (f *FakeProcTableImpl) MarkFailed(pvName string) error {
f.MarkDoneCount++
return f.realTable.MarkFailed(pvName)
} | go | {
"resource": ""
} |
q25521 | MarkSucceeded | train | func (f *FakeProcTableImpl) MarkSucceeded(pvName string) error {
f.MarkDoneCount++
return f.realTable.MarkSucceeded(pvName)
} | go | {
"resource": ""
} |
q25522 | RemoveEntry | train | func (f *FakeProcTableImpl) RemoveEntry(pvName string) (CleanupState, *time.Time, error) {
f.RemoveCount++
return f.realTable.RemoveEntry(pvName)
} | go | {
"resource": ""
} |
q25523 | NewClient | train | func NewClient(cfg *rest.Config) (*rest.RESTClient, *runtime.Scheme, error) {
scheme := runtime.NewScheme()
if err := crdv1.AddToScheme(scheme); err != nil {
return nil, nil, err
}
config := *cfg
config.GroupVersion = &crdv1.SchemeGroupVersion
config.APIPath = "/apis"
config.ContentType = runtime.ContentTypeJ... | go | {
"resource": ""
} |
q25524 | CreateCRD | train | func CreateCRD(clientset apiextensionsclient.Interface) error {
crd := &apiextensionsv1beta1.CustomResourceDefinition{
ObjectMeta: metav1.ObjectMeta{
Name: crdv1.VolumeSnapshotDataResourcePlural + "." + crdv1.GroupName,
},
Spec: apiextensionsv1beta1.CustomResourceDefinitionSpec{
Group: crdv1.GroupName,
... | go | {
"resource": ""
} |
q25525 | WaitForSnapshotResource | train | func WaitForSnapshotResource(snapshotClient *rest.RESTClient) error {
return wait.Poll(100*time.Millisecond, 60*time.Second, func() (bool, error) {
_, err := snapshotClient.Get().
Resource(crdv1.VolumeSnapshotDataResourcePlural).DoRaw()
if err == nil {
return true, nil
}
if apierrors.IsNotFound(err) {
... | go | {
"resource": ""
} |
q25526 | List | train | func (i *Instances) List(nameFilter string) ([]types.NodeName, error) {
glog.V(4).Infof("openstack List(%v) called", nameFilter)
opts := servers.ListOpts{
Name: nameFilter,
Status: "ACTIVE",
}
pager := servers.List(i.compute, opts)
ret := make([]types.NodeName, 0)
err := pager.EachPage(func(page paginatio... | go | {
"resource": ""
} |
q25527 | NodeAddresses | train | func (i *Instances) NodeAddresses(name types.NodeName) ([]v1.NodeAddress, error) {
glog.V(4).Infof("NodeAddresses(%v) called", name)
addrs, err := getAddressesByName(i.compute, name)
if err != nil {
return nil, err
}
glog.V(4).Infof("NodeAddresses(%v) => %v", name, addrs)
return addrs, nil
} | go | {
"resource": ""
} |
q25528 | generateID | train | func generateID(mutex *sync.Mutex, ids map[uint16]bool) uint16 {
mutex.Lock()
id := uint16(1)
for ; id <= math.MaxUint16; id++ {
if _, ok := ids[id]; !ok {
break
}
}
ids[id] = true
mutex.Unlock()
return id
} | go | {
"resource": ""
} |
q25529 | getExistingIDs | train | func getExistingIDs(config string, re *regexp.Regexp) (map[uint16]bool, error) {
ids := map[uint16]bool{}
digitsRe := "([0-9]+)"
if !strings.Contains(re.String(), digitsRe) {
return ids, fmt.Errorf("regexp %s doesn't contain digits submatch %s", re.String(), digitsRe)
}
read, err := ioutil.ReadFile(config)
if... | go | {
"resource": ""
} |
q25530 | NewSnapshotController | train | func NewSnapshotController(client *rest.RESTClient,
scheme *runtime.Scheme,
clientset kubernetes.Interface,
volumePlugins *map[string]volume.Plugin,
syncDuration time.Duration) SnapshotController {
sc := &snapshotController{
snapshotClient: client,
snapshotScheme: scheme,
}
// Watch snapshot objects
sourc... | go | {
"resource": ""
} |
q25531 | Run | train | func (c *snapshotController) Run(ctx <-chan struct{}) {
glog.Infof("Starting snapshot controller")
go c.snapshotController.Run(ctx)
if !kcontroller.WaitForCacheSync("snapshot-controller", ctx, c.snapshotController.HasSynced) {
return
}
go c.reconciler.Run(ctx)
go c.desiredStateOfWorldPopulator.Run(ctx)
} | go | {
"resource": ""
} |
q25532 | ensureLoadBalancerHealthCheck | train | func (c *Cloud) ensureLoadBalancerHealthCheck(loadBalancer *elb.LoadBalancerDescription, listeners []*elb.Listener) error {
name := aws.StringValue(loadBalancer.LoadBalancerName)
actual := loadBalancer.HealthCheck
// Default AWS settings
expectedHealthyThreshold := int64(2)
expectedUnhealthyThreshold := int64(6)... | go | {
"resource": ""
} |
q25533 | CreateImage | train | func (u *RBDUtil) CreateImage(image string, pOpts *rbdProvisionOptions, options controller.VolumeOptions) (*v1.RBDPersistentVolumeSource, int, error) {
var output []byte
var err error
capacity := options.PVC.Spec.Resources.Requests[v1.ResourceName(v1.ResourceStorage)]
volSizeBytes := capacity.Value()
// convert t... | go | {
"resource": ""
} |
q25534 | rbdStatus | train | func (u *RBDUtil) rbdStatus(image string, pOpts *rbdProvisionOptions) (bool, error) {
var err error
var output string
var cmd []byte
mon := u.kernelRBDMonitorsOpt(pOpts.monitors)
// cmd "rbd status" list the rbd client watch with the following output:
//
// # there is a watcher (exit=0)
// Watchers:
// watc... | go | {
"resource": ""
} |
q25535 | DeleteImage | train | func (u *RBDUtil) DeleteImage(image string, pOpts *rbdProvisionOptions) error {
var output []byte
found, err := u.rbdStatus(image, pOpts)
if err != nil {
return err
}
if found {
klog.Info("rbd is still being used ", image)
return fmt.Errorf("rbd %s is still being used", image)
}
// rbd rm
mon := u.kernelR... | go | {
"resource": ""
} |
q25536 | DeleteRoute | train | func (c *Cloud) DeleteRoute(clusterName string, route *cloudprovider.Route) error {
table, err := c.findRouteTable(clusterName)
if err != nil {
return err
}
request := &ec2.DeleteRouteInput{}
request.DestinationCidrBlock = aws.String(route.DestinationCIDR)
request.RouteTableId = table.RouteTableId
_, err = c... | go | {
"resource": ""
} |
q25537 | NewDiscoverer | train | func NewDiscoverer(config *common.RuntimeConfig, cleanupTracker *deleter.CleanupStatusTracker) (*Discoverer, error) {
sharedInformer := config.InformerFactory.Storage().V1().StorageClasses()
sharedInformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{
// We don't need an actual event handler for Stora... | go | {
"resource": ""
} |
q25538 | DiscoverLocalVolumes | train | func (d *Discoverer) DiscoverLocalVolumes() {
for class, config := range d.DiscoveryMap {
d.discoverVolumesAtPath(class, config)
}
} | go | {
"resource": ""
} |
q25539 | roundDownCapacityPretty | train | func roundDownCapacityPretty(capacityBytes int64) int64 {
easyToReadUnitsBytes := []int64{esUtil.GiB, esUtil.MiB}
// Round down to the nearest easy to read unit
// such that there are at least 10 units at that size.
for _, easyToReadUnitBytes := range easyToReadUnitsBytes {
// Round down the capacity to the nea... | go | {
"resource": ""
} |
q25540 | GetStorageNodeAffinityFromAnnotation | train | func GetStorageNodeAffinityFromAnnotation(annotations map[string]string) (*v1.NodeAffinity, error) {
if len(annotations) > 0 && annotations[common.AlphaStorageNodeAffinityAnnotation] != "" {
var affinity v1.NodeAffinity
err := json.Unmarshal([]byte(annotations[common.AlphaStorageNodeAffinityAnnotation]), &affinity... | go | {
"resource": ""
} |
q25541 | StorageNodeAffinityToAlphaAnnotation | train | func StorageNodeAffinityToAlphaAnnotation(annotations map[string]string, affinity *v1.NodeAffinity) error {
if affinity == nil {
return nil
}
json, err := json.Marshal(*affinity)
if err != nil {
return err
}
annotations[common.AlphaStorageNodeAffinityAnnotation] = string(json)
return nil
} | go | {
"resource": ""
} |
q25542 | newGCECloud | train | func newGCECloud(config io.Reader) (*Cloud, error) {
projectID, zone, err := getProjectAndZone()
if err != nil {
return nil, err
}
region, err := GetGCERegion(zone)
if err != nil {
return nil, err
}
networkName, err := getNetworkNameViaMetadata()
if err != nil {
return nil, err
}
networkURL := gceNetw... | go | {
"resource": ""
} |
q25543 | translateAffinityType | train | func translateAffinityType(affinityType v1.ServiceAffinity) string {
switch affinityType {
case v1.ServiceAffinityClientIP:
return gceAffinityTypeClientIP
case v1.ServiceAffinityNone:
return gceAffinityTypeNone
default:
glog.Errorf("Unexpected affinity type: %v", affinityType)
return gceAffinityTypeNone
}
... | go | {
"resource": ""
} |
q25544 | DeleteForwardingRule | train | func (gce *Cloud) DeleteForwardingRule(name string) error {
region, err := GetGCERegion(gce.localZone)
if err != nil {
return err
}
return gce.deleteForwardingRule(name, region)
} | go | {
"resource": ""
} |
q25545 | DeleteTargetPool | train | func (gce *Cloud) DeleteTargetPool(name string, hc *compute.HttpHealthCheck) error {
region, err := GetGCERegion(gce.localZone)
if err != nil {
return err
}
return gce.deleteTargetPool(name, region, hc)
} | go | {
"resource": ""
} |
q25546 | UpdateFirewall | train | func (gce *Cloud) UpdateFirewall(name, desc string, sourceRanges netsets.IPNet, ports []int64, hostNames []string) error {
region, err := GetGCERegion(gce.localZone)
if err != nil {
return err
}
// TODO: This completely breaks modularity in the cloudprovider but the methods
// shared with the TCPLoadBalancer tak... | go | {
"resource": ""
} |
q25547 | DeleteGlobalStaticIP | train | func (gce *Cloud) DeleteGlobalStaticIP(name string) error {
op, err := gce.service.GlobalAddresses.Delete(gce.projectID, name).Do()
if err != nil {
return err
}
return gce.waitForGlobalOp(op)
} | go | {
"resource": ""
} |
q25548 | GetGlobalStaticIP | train | func (gce *Cloud) GetGlobalStaticIP(name string) (address *compute.Address, err error) {
return gce.service.GlobalAddresses.Get(gce.projectID, name).Do()
} | go | {
"resource": ""
} |
q25549 | GetURLMap | train | func (gce *Cloud) GetURLMap(name string) (*compute.UrlMap, error) {
return gce.service.UrlMaps.Get(gce.projectID, name).Do()
} | go | {
"resource": ""
} |
q25550 | CreateURLMap | train | func (gce *Cloud) CreateURLMap(backend *compute.BackendService, name string) (*compute.UrlMap, error) {
urlMap := &compute.UrlMap{
Name: name,
DefaultService: backend.SelfLink,
}
op, err := gce.service.UrlMaps.Insert(gce.projectID, urlMap).Do()
if err != nil {
return nil, err
}
if err = gce.waitFo... | go | {
"resource": ""
} |
q25551 | UpdateURLMap | train | func (gce *Cloud) UpdateURLMap(urlMap *compute.UrlMap) (*compute.UrlMap, error) {
op, err := gce.service.UrlMaps.Update(gce.projectID, urlMap.Name, urlMap).Do()
if err != nil {
return nil, err
}
if err = gce.waitForGlobalOp(op); err != nil {
return nil, err
}
return gce.service.UrlMaps.Get(gce.projectID, urlM... | go | {
"resource": ""
} |
q25552 | ListURLMaps | train | func (gce *Cloud) ListURLMaps() (*compute.UrlMapList, error) {
// TODO: use PageToken to list all not just the first 500
return gce.service.UrlMaps.List(gce.projectID).Do()
} | go | {
"resource": ""
} |
q25553 | GetTargetHTTPProxy | train | func (gce *Cloud) GetTargetHTTPProxy(name string) (*compute.TargetHttpProxy, error) {
return gce.service.TargetHttpProxies.Get(gce.projectID, name).Do()
} | go | {
"resource": ""
} |
q25554 | CreateTargetHTTPProxy | train | func (gce *Cloud) CreateTargetHTTPProxy(urlMap *compute.UrlMap, name string) (*compute.TargetHttpProxy, error) {
proxy := &compute.TargetHttpProxy{
Name: name,
UrlMap: urlMap.SelfLink,
}
op, err := gce.service.TargetHttpProxies.Insert(gce.projectID, proxy).Do()
if err != nil {
return nil, err
}
if err = g... | go | {
"resource": ""
} |
q25555 | SetURLMapForTargetHTTPProxy | train | func (gce *Cloud) SetURLMapForTargetHTTPProxy(proxy *compute.TargetHttpProxy, urlMap *compute.UrlMap) error {
op, err := gce.service.TargetHttpProxies.SetUrlMap(gce.projectID, proxy.Name, &compute.UrlMapReference{UrlMap: urlMap.SelfLink}).Do()
if err != nil {
return err
}
return gce.waitForGlobalOp(op)
} | go | {
"resource": ""
} |
q25556 | ListTargetHTTPProxies | train | func (gce *Cloud) ListTargetHTTPProxies() (*compute.TargetHttpProxyList, error) {
// TODO: use PageToken to list all not just the first 500
return gce.service.TargetHttpProxies.List(gce.projectID).Do()
} | go | {
"resource": ""
} |
q25557 | GetTargetHTTPSProxy | train | func (gce *Cloud) GetTargetHTTPSProxy(name string) (*compute.TargetHttpsProxy, error) {
return gce.service.TargetHttpsProxies.Get(gce.projectID, name).Do()
} | go | {
"resource": ""
} |
q25558 | CreateTargetHTTPSProxy | train | func (gce *Cloud) CreateTargetHTTPSProxy(urlMap *compute.UrlMap, sslCert *compute.SslCertificate, name string) (*compute.TargetHttpsProxy, error) {
proxy := &compute.TargetHttpsProxy{
Name: name,
UrlMap: urlMap.SelfLink,
SslCertificates: []string{sslCert.SelfLink},
}
op, err := gce.service.... | go | {
"resource": ""
} |
q25559 | SetURLMapForTargetHTTPSProxy | train | func (gce *Cloud) SetURLMapForTargetHTTPSProxy(proxy *compute.TargetHttpsProxy, urlMap *compute.UrlMap) error {
op, err := gce.service.TargetHttpsProxies.SetUrlMap(gce.projectID, proxy.Name, &compute.UrlMapReference{UrlMap: urlMap.SelfLink}).Do()
if err != nil {
return err
}
return gce.waitForGlobalOp(op)
} | go | {
"resource": ""
} |
q25560 | SetSslCertificateForTargetHTTPSProxy | train | func (gce *Cloud) SetSslCertificateForTargetHTTPSProxy(proxy *compute.TargetHttpsProxy, sslCert *compute.SslCertificate) error {
op, err := gce.service.TargetHttpsProxies.SetSslCertificates(gce.projectID, proxy.Name, &compute.TargetHttpsProxiesSetSslCertificatesRequest{SslCertificates: []string{sslCert.SelfLink}}).Do(... | go | {
"resource": ""
} |
q25561 | DeleteTargetHTTPSProxy | train | func (gce *Cloud) DeleteTargetHTTPSProxy(name string) error {
op, err := gce.service.TargetHttpsProxies.Delete(gce.projectID, name).Do()
if err != nil {
if isHTTPErrorCode(err, http.StatusNotFound) {
return nil
}
return err
}
return gce.waitForGlobalOp(op)
} | go | {
"resource": ""
} |
q25562 | ListTargetHTTPSProxies | train | func (gce *Cloud) ListTargetHTTPSProxies() (*compute.TargetHttpsProxyList, error) {
// TODO: use PageToken to list all not just the first 500
return gce.service.TargetHttpsProxies.List(gce.projectID).Do()
} | go | {
"resource": ""
} |
q25563 | GetSslCertificate | train | func (gce *Cloud) GetSslCertificate(name string) (*compute.SslCertificate, error) {
return gce.service.SslCertificates.Get(gce.projectID, name).Do()
} | go | {
"resource": ""
} |
q25564 | GetBackendService | train | func (gce *Cloud) GetBackendService(name string) (*compute.BackendService, error) {
return gce.service.BackendServices.Get(gce.projectID, name).Do()
} | go | {
"resource": ""
} |
q25565 | UpdateBackendService | train | func (gce *Cloud) UpdateBackendService(bg *compute.BackendService) error {
op, err := gce.service.BackendServices.Update(gce.projectID, bg.Name, bg).Do()
if err != nil {
return err
}
return gce.waitForGlobalOp(op)
} | go | {
"resource": ""
} |
q25566 | CreateBackendService | train | func (gce *Cloud) CreateBackendService(bg *compute.BackendService) error {
op, err := gce.service.BackendServices.Insert(gce.projectID, bg).Do()
if err != nil {
return err
}
return gce.waitForGlobalOp(op)
} | go | {
"resource": ""
} |
q25567 | ListBackendServices | train | func (gce *Cloud) ListBackendServices() (*compute.BackendServiceList, error) {
// TODO: use PageToken to list all not just the first 500
return gce.service.BackendServices.List(gce.projectID).Do()
} | go | {
"resource": ""
} |
q25568 | GetHealth | train | func (gce *Cloud) GetHealth(name string, instanceGroupLink string) (*compute.BackendServiceGroupHealth, error) {
groupRef := &compute.ResourceGroupReference{Group: instanceGroupLink}
return gce.service.BackendServices.GetHealth(gce.projectID, name, groupRef).Do()
} | go | {
"resource": ""
} |
q25569 | GetHTTPHealthCheck | train | func (gce *Cloud) GetHTTPHealthCheck(name string) (*compute.HttpHealthCheck, error) {
return gce.service.HttpHealthChecks.Get(gce.projectID, name).Do()
} | go | {
"resource": ""
} |
q25570 | UpdateHTTPHealthCheck | train | func (gce *Cloud) UpdateHTTPHealthCheck(hc *compute.HttpHealthCheck) error {
op, err := gce.service.HttpHealthChecks.Update(gce.projectID, hc.Name, hc).Do()
if err != nil {
return err
}
return gce.waitForGlobalOp(op)
} | go | {
"resource": ""
} |
q25571 | CreateHTTPHealthCheck | train | func (gce *Cloud) CreateHTTPHealthCheck(hc *compute.HttpHealthCheck) error {
op, err := gce.service.HttpHealthChecks.Insert(gce.projectID, hc).Do()
if err != nil {
return err
}
return gce.waitForGlobalOp(op)
} | go | {
"resource": ""
} |
q25572 | ListHTTPHealthChecks | train | func (gce *Cloud) ListHTTPHealthChecks() (*compute.HttpHealthCheckList, error) {
// TODO: use PageToken to list all not just the first 500
return gce.service.HttpHealthChecks.List(gce.projectID).Do()
} | go | {
"resource": ""
} |
q25573 | CreateInstanceGroup | train | func (gce *Cloud) CreateInstanceGroup(name string, zone string) (*compute.InstanceGroup, error) {
op, err := gce.service.InstanceGroups.Insert(
gce.projectID, zone, &compute.InstanceGroup{Name: name}).Do()
if err != nil {
return nil, err
}
if err = gce.waitForZoneOp(op, zone); err != nil {
return nil, err
}
... | go | {
"resource": ""
} |
q25574 | RemoveInstancesFromInstanceGroup | train | func (gce *Cloud) RemoveInstancesFromInstanceGroup(name string, zone string, instanceNames []string) error {
if len(instanceNames) == 0 {
return nil
}
instances := []*compute.InstanceReference{}
for _, ins := range instanceNames {
instanceLink := makeHostURL(gce.projectID, zone, ins)
instances = append(instan... | go | {
"resource": ""
} |
q25575 | AddPortToInstanceGroup | train | func (gce *Cloud) AddPortToInstanceGroup(ig *compute.InstanceGroup, port int64) (*compute.NamedPort, error) {
for _, np := range ig.NamedPorts {
if np.Port == port {
glog.V(3).Infof("Instance group %v already has named port %+v", ig.Name, np)
return np, nil
}
}
glog.Infof("Adding port %v to instance group ... | go | {
"resource": ""
} |
q25576 | CurrentNodeName | train | func (gce *Cloud) CurrentNodeName(hostname string) (types.NodeName, error) {
return types.NodeName(hostname), nil
} | go | {
"resource": ""
} |
q25577 | GetAllZones | train | func (gce *Cloud) GetAllZones() (sets.String, error) {
// Fast-path for non-multizone
if len(gce.managedZones) == 1 {
return sets.NewString(gce.managedZones...), nil
}
// TODO: Caching, but this is currently only called when we are creating a volume,
// which is a relatively infrequent operation, and this is on... | go | {
"resource": ""
} |
q25578 | ListRoutes | train | func (gce *Cloud) ListRoutes(clusterName string) ([]*cloudprovider.Route, error) {
var routes []*cloudprovider.Route
pageToken := ""
page := 0
for ; page == 0 || (pageToken != "" && page < maxPages); page++ {
listCall := gce.service.Routes.List(gce.projectID)
prefix := truncateClusterName(clusterName)
listCa... | go | {
"resource": ""
} |
q25579 | GetZone | train | func (gce *Cloud) GetZone() (cloudprovider.Zone, error) {
return cloudprovider.Zone{
FailureDomain: gce.localZone,
Region: gce.region,
}, nil
} | go | {
"resource": ""
} |
q25580 | DeleteDisk | train | func (gce *Cloud) DeleteDisk(diskToDelete string) error {
err := gce.doDeleteDisk(diskToDelete)
if isGCEError(err, "resourceInUseByAnotherResource") {
return volume.NewDeletedVolumeInUseError(err.Error())
}
if err == cloudprovider.ErrDiskNotFound {
return nil
}
return err
} | go | {
"resource": ""
} |
q25581 | AttachDisk | train | func (gce *Cloud) AttachDisk(diskName string, nodeName types.NodeName, readOnly bool) error {
instanceName := mapNodeNameToInstanceName(nodeName)
instance, err := gce.getInstanceByName(instanceName)
if err != nil {
return fmt.Errorf("error getting instance %q", instanceName)
}
disk, err := gce.getDiskByName(disk... | go | {
"resource": ""
} |
q25582 | DetachDisk | train | func (gce *Cloud) DetachDisk(devicePath string, nodeName types.NodeName) error {
instanceName := mapNodeNameToInstanceName(nodeName)
inst, err := gce.getInstanceByName(instanceName)
if err != nil {
if err == cloudprovider.ErrInstanceNotFound {
// If instance no longer exists, safe to assume volume is not attach... | go | {
"resource": ""
} |
q25583 | DiskIsAttached | train | func (gce *Cloud) DiskIsAttached(diskName string, nodeName types.NodeName) (bool, error) {
instanceName := mapNodeNameToInstanceName(nodeName)
instance, err := gce.getInstanceByName(instanceName)
if err != nil {
if err == cloudprovider.ErrInstanceNotFound {
// If instance no longer exists, safe to assume volume... | go | {
"resource": ""
} |
q25584 | getDiskByNameUnknownZone | train | func (gce *Cloud) getDiskByNameUnknownZone(diskName string) (*gceDisk, error) {
// Note: this is the gotcha right now with GCE PD support:
// disk names are not unique per-region.
// (I can create two volumes with name "myvol" in e.g. us-central1-b & us-central1-f)
// For now, this is simply undefined behaviour.
/... | go | {
"resource": ""
} |
q25585 | convertDiskToAttachedDisk | train | func (gce *Cloud) convertDiskToAttachedDisk(disk *gceDisk, readWrite string) *compute.AttachedDisk {
return &compute.AttachedDisk{
DeviceName: disk.Name,
Kind: disk.Kind,
Mode: readWrite,
Source: "https://" + path.Join("www.googleapis.com/compute/v1/projects/", gce.projectID, "zones", disk.Zone... | go | {
"resource": ""
} |
q25586 | CreateDiskFromSnapshot | train | func (gce *Cloud) CreateDiskFromSnapshot(snapshot string,
name string, diskType string, zone string, sizeGb int64, tags map[string]string) error {
// Do not allow creation of PDs in zones that are not managed. Such PDs
// then cannot be deleted by DeleteDisk.
isManaged := false
for _, managedZone := range gce.man... | go | {
"resource": ""
} |
q25587 | DescribeSnapshot | train | func (gce *Cloud) DescribeSnapshot(snapshotToGet string) (status string, isCompleted bool, err error) {
snapshot, err := gce.getSnapshotByName(snapshotToGet)
if err != nil {
return "", false, err
}
//no snapshot is found
if snapshot == nil {
return "", false, fmt.Errorf("snapshot %s is not found", snapshotToGe... | go | {
"resource": ""
} |
q25588 | FindSnapshot | train | func (gce *Cloud) FindSnapshot(tags map[string]string) ([]string, []string, error) {
var snapshotIDs, statuses []string
return snapshotIDs, statuses, nil
} | go | {
"resource": ""
} |
q25589 | DeleteSnapshot | train | func (gce *Cloud) DeleteSnapshot(snapshotToDelete string) error {
snapshot, err := gce.getSnapshotByName(snapshotToDelete)
if err != nil {
return err
}
//no snapshot is found
if snapshot == nil {
return nil
}
deleteOp, err := gce.service.Snapshots.Delete(gce.projectID, snapshotToDelete).Do()
if err != nil... | go | {
"resource": ""
} |
q25590 | CreateSnapshot | train | func (gce *Cloud) CreateSnapshot(diskName string, zone string, snapshotName string, tags map[string]string) error {
isManaged := false
for _, managedZone := range gce.managedZones {
if zone == managedZone {
isManaged = true
break
}
}
if !isManaged {
return fmt.Errorf("kubernetes does not manage zone %q"... | go | {
"resource": ""
} |
q25591 | ListClusters | train | func (gce *Cloud) ListClusters() ([]string, error) {
allClusters := []string{}
for _, zone := range gce.managedZones {
clusters, err := gce.listClustersInZone(zone)
if err != nil {
return nil, err
}
// TODO: Scoping? Do we need to qualify the cluster name?
allClusters = append(allClusters, clusters...)... | go | {
"resource": ""
} |
q25592 | getInstancesByNames | train | func (gce *Cloud) getInstancesByNames(names []string) ([]*gceInstance, error) {
instances := make(map[string]*gceInstance)
remaining := len(names)
nodeInstancePrefix := gce.nodeInstancePrefix
for _, name := range names {
name = canonicalizeInstanceName(name)
if !strings.HasPrefix(name, gce.nodeInstancePrefix) ... | go | {
"resource": ""
} |
q25593 | getInstanceByName | train | func (gce *Cloud) getInstanceByName(name string) (*gceInstance, error) {
// Avoid changing behaviour when not managing multiple zones
for _, zone := range gce.managedZones {
name = canonicalizeInstanceName(name)
res, err := gce.service.Instances.Get(gce.projectID, zone, name).Do()
if err != nil {
glog.Errorf... | go | {
"resource": ""
} |
q25594 | Set | train | func (a Attrs) Set(name string, expr bzl.Expr) {
a[name] = expr
} | go | {
"resource": ""
} |
q25595 | SetList | train | func (a Attrs) SetList(name string, expr *bzl.ListExpr) {
if len(expr.List) == 0 {
return
}
a[name] = expr
} | go | {
"resource": ""
} |
q25596 | findBuildFile | train | func findBuildFile(pkgPath string) (bool, string) {
options := []string{"BUILD.bazel", "BUILD"}
for _, b := range options {
path := filepath.Join(pkgPath, b)
info, err := os.Stat(path)
if err == nil && !info.IsDir() {
return true, path
}
}
return false, filepath.Join(pkgPath, "BUILD")
} | go | {
"resource": ""
} |
q25597 | ReconcileRules | train | func ReconcileRules(pkgPath string, rules []*bzl.Rule, managedAttrs []string, dryRun bool) (bool, error) {
_, path := findBuildFile(pkgPath)
info, err := os.Stat(path)
if err != nil && os.IsNotExist(err) {
f := &bzl.File{}
writeHeaders(f)
reconcileLoad(f, rules)
writeRules(f, rules)
return writeFile(path, ... | go | {
"resource": ""
} |
q25598 | RuleIsManaged | train | func RuleIsManaged(r *bzl.Rule) bool {
var automanaged bool
for _, tag := range r.AttrStrings("tags") {
if tag == automanagedTag {
automanaged = true
break
}
}
return automanaged
} | go | {
"resource": ""
} |
q25599 | CloudProviders | train | func CloudProviders() []string {
names := []string{}
providersMutex.Lock()
defer providersMutex.Unlock()
for name := range providers {
names = append(names, name)
}
return names
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.