_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q25600 | GetBlockCapacityByte | train | func (u *volumeUtil) GetBlockCapacityByte(fullPath string) (int64, error) {
file, err := os.OpenFile(fullPath, os.O_RDONLY, 0)
if err != nil {
return 0, err
}
defer file.Close()
var size int64
// Get size of block device into 64 bit int.
// Ref: http://www.microhowto.info/howto/get_the_size_of_a_linux_block_s... | go | {
"resource": ""
} |
q25601 | CreateLocalPVSpec | train | func CreateLocalPVSpec(config *LocalPVConfig) *v1.PersistentVolume {
pv := &v1.PersistentVolume{
ObjectMeta: metav1.ObjectMeta{
Name: config.Name,
Labels: config.Labels,
Annotations: map[string]string{
AnnProvisionedBy: config.ProvisionerName,
},
},
Spec: v1.PersistentVolumeSpec{
PersistentV... | go | {
"resource": ""
} |
q25602 | GetVolumeConfigFromConfigMap | train | func GetVolumeConfigFromConfigMap(client *kubernetes.Clientset, namespace, name string, provisionerConfig *ProvisionerConfiguration) error {
configMap, err := client.CoreV1().ConfigMaps(namespace).Get(name, metav1.GetOptions{})
if err != nil {
return err
}
err = ConfigMapDataToVolumeConfig(configMap.Data, provisi... | go | {
"resource": ""
} |
q25603 | VolumeConfigToConfigMapData | train | func VolumeConfigToConfigMapData(config *ProvisionerConfiguration) (map[string]string, error) {
configMapData := make(map[string]string)
val, err := yaml.Marshal(config.StorageClassConfig)
if err != nil {
return nil, fmt.Errorf("unable to Marshal volume config: %v", err)
}
configMapData[ProvisonerStorageClassCon... | go | {
"resource": ""
} |
q25604 | ConfigMapDataToVolumeConfig | train | func ConfigMapDataToVolumeConfig(data map[string]string, provisionerConfig *ProvisionerConfiguration) error {
rawYaml := ""
for key, val := range data {
rawYaml += key
rawYaml += ": \n"
rawYaml += insertSpaces(string(val))
}
if err := yaml.Unmarshal([]byte(rawYaml), provisionerConfig); err != nil {
return ... | go | {
"resource": ""
} |
q25605 | LoadProvisionerConfigs | train | func LoadProvisionerConfigs(configPath string, provisionerConfig *ProvisionerConfiguration) error {
files, err := ioutil.ReadDir(configPath)
if err != nil {
return err
}
data := make(map[string]string)
for _, file := range files {
if !file.IsDir() {
if strings.Compare(file.Name(), "..data") != 0 {
fileC... | go | {
"resource": ""
} |
q25606 | SetupClient | train | func SetupClient() *kubernetes.Clientset {
var config *rest.Config
var err error
kubeconfigFile := os.Getenv(KubeConfigEnv)
if kubeconfigFile != "" {
config, err = BuildConfigFromFlags("", kubeconfigFile)
if err != nil {
glog.Fatalf("Error creating config from %s specified file: %s %v\n", KubeConfigEnv,
... | go | {
"resource": ""
} |
q25607 | GenerateMountName | train | func GenerateMountName(mount *MountConfig) string {
h := fnv.New32a()
h.Write([]byte(mount.HostDir))
h.Write([]byte(mount.MountDir))
return fmt.Sprintf("mount-%x", h.Sum32())
} | go | {
"resource": ""
} |
q25608 | GetVolumeMode | train | func GetVolumeMode(volUtil util.VolumeUtil, fullPath string) (v1.PersistentVolumeMode, error) {
isdir, errdir := volUtil.IsDir(fullPath)
if isdir {
return v1.PersistentVolumeFilesystem, nil
}
// check for Block before returning errdir
isblk, errblk := volUtil.IsBlock(fullPath)
if isblk {
return v1.PersistentV... | go | {
"resource": ""
} |
q25609 | Delete | train | func (p *nfsProvisioner) Delete(volume *v1.PersistentVolume) error {
// Ignore the call if this provisioner was not the one to provision the
// volume. It doesn't even attempt to delete it, so it's neither a success
// (nil error) nor failure (any other error)
provisioned, err := p.provisioned(volume)
if err != ni... | go | {
"resource": ""
} |
q25610 | NewDigitalOceanProvisioner | train | func NewDigitalOceanProvisioner(ctx context.Context, client kubernetes.Interface, doClient *godo.Client) controller.Provisioner {
var identity types.UID
provisioner := &digitaloceanProvisioner{
client: client,
doClient: doClient,
ctx: ctx,
identity: identity,
}
return provisioner
} | go | {
"resource": ""
} |
q25611 | getAccessModes | train | func (p *iscsiProvisioner) getAccessModes() []v1.PersistentVolumeAccessMode {
return []v1.PersistentVolumeAccessMode{
v1.ReadWriteOnce,
v1.ReadOnlyMany,
}
} | go | {
"resource": ""
} |
q25612 | getFirstAvailableLun | train | func getFirstAvailableLun(exportList exportList) (int32, error) {
sort.Sort(exportList)
log.Debug("sorted export List: ", exportList)
//this is sloppy way to remove duplicates
uniqueExport := make(map[int32]export)
for _, export := range exportList {
uniqueExport[export.Lun] = export
}
log.Debug("unique luns s... | go | {
"resource": ""
} |
q25613 | volDestroy | train | func (p *iscsiProvisioner) volDestroy(vol string, pool string) error {
client, err := p.getConnection()
defer client.Close()
if err != nil {
log.Warnln(err)
return err
}
args := volDestroyArgs{
Pool: pool,
Name: vol,
}
err = client.Call("vol_destroy", args, nil)
return err
} | go | {
"resource": ""
} |
q25614 | exportDestroy | train | func (p *iscsiProvisioner) exportDestroy(vol string, pool string, initiator string) error {
client, err := p.getConnection()
defer client.Close()
if err != nil {
log.Warnln(err)
return err
}
args := exportDestroyArgs{
Pool: pool,
Vol: vol,
InitiatorWwn: initiator,
}
err = client.Call("... | go | {
"resource": ""
} |
q25615 | volCreate | train | func (p *iscsiProvisioner) volCreate(name string, size int64, pool string) error {
client, err := p.getConnection()
defer client.Close()
if err != nil {
log.Warnln(err)
return err
}
args := volCreateArgs{
Pool: pool,
Name: name,
Size: size,
}
err = client.Call("vol_create", args, nil)
return err
} | go | {
"resource": ""
} |
q25616 | exportCreate | train | func (p *iscsiProvisioner) exportCreate(vol string, lun int32, pool string, initiator string) error {
client, err := p.getConnection()
defer client.Close()
if err != nil {
log.Warnln(err)
return err
}
args := exportCreateArgs{
Pool: pool,
Vol: vol,
InitiatorWwn: initiator,
Lun: ... | go | {
"resource": ""
} |
q25617 | exportList | train | func (p *iscsiProvisioner) exportList() (exportList, error) {
client, err := p.getConnection()
defer client.Close()
if err != nil {
log.Warnln(err)
return nil, err
}
var result1 exportList
err = client.Call("export_list", nil, &result1)
return result1, err
} | go | {
"resource": ""
} |
q25618 | walkSource | train | func (v *Vendorer) walkSource(pkgPath string) ([]string, error) {
// clean pkgPath since we access v.newRules directly
pkgPath = filepath.Clean(pkgPath)
for _, r := range v.skippedPaths {
if r.Match([]byte(pkgPath)) {
return nil, nil
}
}
files, err := ioutil.ReadDir(pkgPath)
if err != nil {
return nil, e... | go | {
"resource": ""
} |
q25619 | NewNetworkV2 | train | func (os *OpenStack) NewNetworkV2() (*gophercloud.ServiceClient, error) {
network, err := openstack.NewNetworkV2(os.provider, gophercloud.EndpointOpts{
Region: os.region,
})
if err != nil {
glog.Warningf("Failed to find network v2 endpoint: %v", err)
return nil, err
}
return network, nil
} | go | {
"resource": ""
} |
q25620 | NewComputeV2 | train | func (os *OpenStack) NewComputeV2() (*gophercloud.ServiceClient, error) {
compute, err := openstack.NewComputeV2(os.provider, gophercloud.EndpointOpts{
Region: os.region,
})
if err != nil {
glog.Warningf("Failed to find compute v2 endpoint: %v", err)
return nil, err
}
return compute, nil
} | go | {
"resource": ""
} |
q25621 | OperationPending | train | func (os *OpenStack) OperationPending(diskName string) (bool, string, error) {
volume, err := os.getVolume(diskName)
if err != nil {
return false, "", err
}
volumeStatus := volume.Status
if volumeStatus == VolumeErrorStatus {
glog.Errorf("status of volume %s is %s", diskName, volumeStatus)
return false, volu... | go | {
"resource": ""
} |
q25622 | AttachDisk | train | func (os *OpenStack) AttachDisk(instanceID, volumeID string) (string, error) {
volume, err := os.getVolume(volumeID)
if err != nil {
return "", err
}
if volume.Status != VolumeAvailableStatus {
errmsg := fmt.Sprintf("volume %s status is %s, not %s, can not be attached to instance %s.", volume.Name, volume.Statu... | go | {
"resource": ""
} |
q25623 | DeleteVolume | train | func (os *OpenStack) DeleteVolume(volumeID string) error {
used, err := os.diskIsUsed(volumeID)
if err != nil {
return err
}
if used {
msg := fmt.Sprintf("Cannot delete the volume %q, it's still attached to a node", volumeID)
return k8sVolume.NewDeletedVolumeInUseError(msg)
}
volumes, err := os.volumeServi... | go | {
"resource": ""
} |
q25624 | GetAttachmentDiskPath | train | func (os *OpenStack) GetAttachmentDiskPath(instanceID, volumeID string) (string, error) {
// See issue #33128 - Cinder does not always tell you the right device path, as such
// we must only use this value as a last resort.
volume, err := os.getVolume(volumeID)
if err != nil {
return "", err
}
if volume.Status ... | go | {
"resource": ""
} |
q25625 | NewPopulator | train | func NewPopulator(config *common.RuntimeConfig) *Populator {
p := &Populator{RuntimeConfig: config}
sharedInformer := config.InformerFactory.Core().V1().PersistentVolumes()
sharedInformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{
AddFunc: func(obj interface{}) {
pv, ok := obj.(*v1.PersistentVo... | go | {
"resource": ""
} |
q25626 | IsDir | train | func (u *volumeUtil) IsDir(fullPath string) (bool, error) {
dir, err := os.Open(fullPath)
if err != nil {
return false, err
}
defer dir.Close()
stat, err := dir.Stat()
if err != nil {
return false, err
}
return stat.IsDir(), nil
} | go | {
"resource": ""
} |
q25627 | ReadDir | train | func (u *volumeUtil) ReadDir(fullPath string) ([]string, error) {
dir, err := os.Open(fullPath)
if err != nil {
return nil, err
}
defer dir.Close()
files, err := dir.Readdirnames(-1)
if err != nil {
return nil, err
}
return files, nil
} | go | {
"resource": ""
} |
q25628 | DeleteContents | train | func (u *volumeUtil) DeleteContents(fullPath string) error {
dir, err := os.Open(fullPath)
if err != nil {
return err
}
defer dir.Close()
files, err := dir.Readdirnames(-1)
if err != nil {
return err
}
errList := []error{}
for _, file := range files {
err = os.RemoveAll(filepath.Join(fullPath, file))
... | go | {
"resource": ""
} |
q25629 | GetFsCapacityByte | train | func (u *volumeUtil) GetFsCapacityByte(fullPath string) (int64, error) {
_, capacity, _, _, _, _, err := fs.FsInfo(fullPath)
return capacity, err
} | go | {
"resource": ""
} |
q25630 | NewFakeVolumeUtil | train | func NewFakeVolumeUtil(deleteShouldFail bool, dirFiles map[string][]*FakeDirEntry) *FakeVolumeUtil {
return &FakeVolumeUtil{
directoryFiles: dirFiles,
deleteShouldFail: deleteShouldFail,
}
} | go | {
"resource": ""
} |
q25631 | ReadDir | train | func (u *FakeVolumeUtil) ReadDir(fullPath string) ([]string, error) {
fileNames := []string{}
files, found := u.directoryFiles[fullPath]
if !found {
return nil, fmt.Errorf("Directory %q not found", fullPath)
}
for _, file := range files {
fileNames = append(fileNames, file.Name)
}
return fileNames, nil
} | go | {
"resource": ""
} |
q25632 | DeleteContents | train | func (u *FakeVolumeUtil) DeleteContents(fullPath string) error {
if u.deleteShouldFail {
return fmt.Errorf("Fake delete contents failed")
}
return nil
} | go | {
"resource": ""
} |
q25633 | GetFsCapacityByte | train | func (u *FakeVolumeUtil) GetFsCapacityByte(fullPath string) (int64, error) {
return u.getDirEntryCapacity(fullPath, FakeEntryFile)
} | go | {
"resource": ""
} |
q25634 | GetBlockCapacityByte | train | func (u *FakeVolumeUtil) GetBlockCapacityByte(fullPath string) (int64, error) {
return u.getDirEntryCapacity(fullPath, FakeEntryBlock)
} | go | {
"resource": ""
} |
q25635 | AddNewDirEntries | train | func (u *FakeVolumeUtil) AddNewDirEntries(mountDir string, dirFiles map[string][]*FakeDirEntry) {
for dir, files := range dirFiles {
mountedPath := filepath.Join(mountDir, dir)
curFiles := u.directoryFiles[mountedPath]
if curFiles == nil {
curFiles = []*FakeDirEntry{}
}
glog.Infof("Adding to directory %q:... | go | {
"resource": ""
} |
q25636 | GetSupportedVolumeFromPVSpec | train | func GetSupportedVolumeFromPVSpec(spec *core_v1.PersistentVolumeSpec) string {
if spec.HostPath != nil {
return "hostPath"
}
if spec.AWSElasticBlockStore != nil {
return "aws_ebs"
}
if spec.GCEPersistentDisk != nil {
return "gce-pd"
}
if spec.Cinder != nil {
return "cinder"
}
if spec.Glusterfs != nil {... | go | {
"resource": ""
} |
q25637 | GetSupportedVolumeFromSnapshotDataSpec | train | func GetSupportedVolumeFromSnapshotDataSpec(spec *VolumeSnapshotDataSpec) string {
if spec.HostPath != nil {
return "hostPath"
}
if spec.AWSElasticBlockStore != nil {
return "aws_ebs"
}
if spec.GCEPersistentDiskSnapshot != nil {
return "gce-pd"
}
if spec.CinderSnapshot != nil {
return "cinder"
}
if spe... | go | {
"resource": ""
} |
q25638 | UnmarshalJSON | train | func (v *VolumeSnapshot) UnmarshalJSON(data []byte) error {
tmp := VolumeSnapshotCopy{}
err := json.Unmarshal(data, &tmp)
if err != nil {
return err
}
tmp2 := VolumeSnapshot(tmp)
*v = tmp2
return nil
} | go | {
"resource": ""
} |
q25639 | CreateSnapshot | train | func (os *OpenStack) CreateSnapshot(sourceVolumeID, name, description string, tags map[string]string) (string, string, error) {
snapshots, err := os.snapshotService()
if err != nil || snapshots == nil {
glog.Errorf("Unable to initialize cinder client for region: %s", os.region)
return "", "", fmt.Errorf("Failed t... | go | {
"resource": ""
} |
q25640 | DeleteSnapshot | train | func (os *OpenStack) DeleteSnapshot(snapshotID string) error {
snapshots, err := os.snapshotService()
if err != nil || snapshots == nil {
glog.Errorf("Unable to initialize cinder client for region: %s", os.region)
return err
}
err = snapshots.deleteSnapshot(snapshotID)
if err != nil {
glog.Errorf("Cannot de... | go | {
"resource": ""
} |
q25641 | FindSnapshot | train | func (os *OpenStack) FindSnapshot(tags map[string]string) ([]string, []string, error) {
var snapshotIDs, statuses []string
ss, err := os.snapshotService()
if err != nil || ss == nil {
glog.Errorf("Unable to initialize cinder client for region: %s", os.region)
return snapshotIDs, statuses, fmt.Errorf("Failed to f... | go | {
"resource": ""
} |
q25642 | ReadCfg | train | func ReadCfg(cfgPath string) (*Cfg, error) {
b, err := ioutil.ReadFile(cfgPath)
if err != nil {
return nil, err
}
var cfg Cfg
if err := json.Unmarshal(b, &cfg); err != nil {
return nil, err
}
defaultCfg(&cfg)
return &cfg, nil
} | go | {
"resource": ""
} |
q25643 | findOpenAPI | train | func (v *Vendorer) findOpenAPI(root string) ([]string, error) {
finfos, err := ioutil.ReadDir(root)
if err != nil {
return nil, err
}
var res []string
var includeMe bool
for _, finfo := range finfos {
path := filepath.Join(root, finfo.Name())
if finfo.IsDir() && (finfo.Mode()&os.ModeSymlink == 0) {
child... | go | {
"resource": ""
} |
q25644 | NewRBDProvisioner | train | func NewRBDProvisioner(client kubernetes.Interface, id string, timeout int, usePVName bool) controller.Provisioner {
return &rbdProvisioner{
client: client,
identity: id,
rbdUtil: &RBDUtil{
timeout: timeout,
},
usePVName: usePVName,
}
} | go | {
"resource": ""
} |
q25645 | getAccessModes | train | func (p *rbdProvisioner) getAccessModes() []v1.PersistentVolumeAccessMode {
return []v1.PersistentVolumeAccessMode{
v1.ReadWriteOnce,
v1.ReadOnlyMany,
}
} | go | {
"resource": ""
} |
q25646 | parsePVSecret | train | func (p *rbdProvisioner) parsePVSecret(namespace, secretName string) (string, error) {
if p.client == nil {
return "", fmt.Errorf("Cannot get kube client")
}
secrets, err := p.client.CoreV1().Secrets(namespace).Get(secretName, metav1.GetOptions{})
if err != nil {
return "", err
}
// TODO: Should we check secr... | go | {
"resource": ""
} |
q25647 | DeepCopy | train | func (in *AWSElasticBlockStoreVolumeSnapshotSource) DeepCopy() *AWSElasticBlockStoreVolumeSnapshotSource {
if in == nil {
return nil
}
out := new(AWSElasticBlockStoreVolumeSnapshotSource)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q25648 | DeepCopy | train | func (in *CinderVolumeSnapshotSource) DeepCopy() *CinderVolumeSnapshotSource {
if in == nil {
return nil
}
out := new(CinderVolumeSnapshotSource)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q25649 | DeepCopy | train | func (in *GCEPersistentDiskSnapshotSource) DeepCopy() *GCEPersistentDiskSnapshotSource {
if in == nil {
return nil
}
out := new(GCEPersistentDiskSnapshotSource)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q25650 | DeepCopy | train | func (in *GlusterVolumeSnapshotSource) DeepCopy() *GlusterVolumeSnapshotSource {
if in == nil {
return nil
}
out := new(GlusterVolumeSnapshotSource)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q25651 | DeepCopy | train | func (in *HostPathVolumeSnapshotSource) DeepCopy() *HostPathVolumeSnapshotSource {
if in == nil {
return nil
}
out := new(HostPathVolumeSnapshotSource)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q25652 | DeepCopy | train | func (in *VolumeSnapshot) DeepCopy() *VolumeSnapshot {
if in == nil {
return nil
}
out := new(VolumeSnapshot)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q25653 | DeepCopy | train | func (in *VolumeSnapshotCondition) DeepCopy() *VolumeSnapshotCondition {
if in == nil {
return nil
}
out := new(VolumeSnapshotCondition)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q25654 | DeepCopy | train | func (in *VolumeSnapshotCopy) DeepCopy() *VolumeSnapshotCopy {
if in == nil {
return nil
}
out := new(VolumeSnapshotCopy)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q25655 | DeepCopy | train | func (in *VolumeSnapshotData) DeepCopy() *VolumeSnapshotData {
if in == nil {
return nil
}
out := new(VolumeSnapshotData)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q25656 | DeepCopy | train | func (in *VolumeSnapshotDataCondition) DeepCopy() *VolumeSnapshotDataCondition {
if in == nil {
return nil
}
out := new(VolumeSnapshotDataCondition)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q25657 | DeepCopy | train | func (in *VolumeSnapshotDataCopy) DeepCopy() *VolumeSnapshotDataCopy {
if in == nil {
return nil
}
out := new(VolumeSnapshotDataCopy)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q25658 | DeepCopy | train | func (in *VolumeSnapshotDataList) DeepCopy() *VolumeSnapshotDataList {
if in == nil {
return nil
}
out := new(VolumeSnapshotDataList)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q25659 | DeepCopy | train | func (in *VolumeSnapshotDataListCopy) DeepCopy() *VolumeSnapshotDataListCopy {
if in == nil {
return nil
}
out := new(VolumeSnapshotDataListCopy)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q25660 | DeepCopy | train | func (in *VolumeSnapshotDataSource) DeepCopy() *VolumeSnapshotDataSource {
if in == nil {
return nil
}
out := new(VolumeSnapshotDataSource)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q25661 | DeepCopy | train | func (in *VolumeSnapshotDataSpec) DeepCopy() *VolumeSnapshotDataSpec {
if in == nil {
return nil
}
out := new(VolumeSnapshotDataSpec)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q25662 | DeepCopy | train | func (in *VolumeSnapshotDataStatus) DeepCopy() *VolumeSnapshotDataStatus {
if in == nil {
return nil
}
out := new(VolumeSnapshotDataStatus)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q25663 | DeepCopy | train | func (in *VolumeSnapshotList) DeepCopy() *VolumeSnapshotList {
if in == nil {
return nil
}
out := new(VolumeSnapshotList)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q25664 | DeepCopy | train | func (in *VolumeSnapshotListCopy) DeepCopy() *VolumeSnapshotListCopy {
if in == nil {
return nil
}
out := new(VolumeSnapshotListCopy)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q25665 | DeepCopy | train | func (in *VolumeSnapshotSpec) DeepCopy() *VolumeSnapshotSpec {
if in == nil {
return nil
}
out := new(VolumeSnapshotSpec)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q25666 | DeepCopy | train | func (in *VolumeSnapshotStatus) DeepCopy() *VolumeSnapshotStatus {
if in == nil {
return nil
}
out := new(VolumeSnapshotStatus)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q25667 | GetLoadBalancer | train | func (lbaas *LbaasV2) GetLoadBalancer(clusterName string, service *v1.Service) (*v1.LoadBalancerStatus, bool, error) {
loadBalancerName := cloudprovider.GetLoadBalancerName(service)
loadbalancer, err := getLoadbalancerByName(lbaas.network, loadBalancerName)
if err == ErrNotFound {
return nil, false, nil
}
if loa... | go | {
"resource": ""
} |
q25668 | GetLoadBalancer | train | func (lb *LbaasV1) GetLoadBalancer(clusterName string, service *v1.Service) (*v1.LoadBalancerStatus, bool, error) {
loadBalancerName := cloudprovider.GetLoadBalancerName(service)
vip, err := getVipByName(lb.network, loadBalancerName)
if err == ErrNotFound {
return nil, false, nil
}
if vip == nil {
return nil, ... | go | {
"resource": ""
} |
q25669 | GetMayaClusterIP | train | func (v OpenEBSVolume) GetMayaClusterIP(client kubernetes.Interface) (string, error) {
clusterIP := "127.0.0.1"
namespace := os.Getenv("OPENEBS_NAMESPACE")
if namespace == "" {
namespace = "default"
}
glog.Info("OpenEBS volume provisioner namespace ", namespace)
//Fetch the Maya ClusterIP using the Maya API S... | go | {
"resource": ""
} |
q25670 | CreateVolume | train | func (v OpenEBSVolume) CreateVolume(vs mayav1.VolumeSpec) (string, error) {
addr := os.Getenv("MAPI_ADDR")
if addr == "" {
err := errors.New("MAPI_ADDR environment variable not set")
glog.Errorf("Error getting maya-apiserver IP Address: %v", err)
return "Error getting maya-apiserver IP Address", err
}
url :=... | go | {
"resource": ""
} |
q25671 | ListVolume | train | func (v OpenEBSVolume) ListVolume(vname string, obj interface{}) error {
addr := os.Getenv("MAPI_ADDR")
if addr == "" {
err := errors.New("MAPI_ADDR environment variable not set")
glog.Errorf("Error getting mayaapi-server IP Address: %v", err)
return err
}
url := addr + "/latest/volumes/info/" + vname
glog... | go | {
"resource": ""
} |
q25672 | NewEFSProvisioner | train | func NewEFSProvisioner(client kubernetes.Interface) controller.Provisioner {
fileSystemID := os.Getenv(fileSystemIDKey)
if fileSystemID == "" {
klog.Fatalf("environment variable %s is not set! Please set it.", fileSystemIDKey)
}
awsRegion := os.Getenv(awsRegionKey)
if awsRegion == "" {
klog.Fatalf("environmen... | go | {
"resource": ""
} |
q25673 | CreatePV | train | func (u *apiUtil) CreatePV(pv *v1.PersistentVolume) (*v1.PersistentVolume, error) {
startTime := time.Now()
metrics.APIServerRequestsTotal.WithLabelValues(metrics.APIServerRequestCreate).Inc()
pv, err := u.client.CoreV1().PersistentVolumes().Create(pv)
metrics.APIServerRequestsDurationSeconds.WithLabelValues(metric... | go | {
"resource": ""
} |
q25674 | DeletePV | train | func (u *apiUtil) DeletePV(pvName string) error {
startTime := time.Now()
metrics.APIServerRequestsTotal.WithLabelValues(metrics.APIServerRequestDelete).Inc()
err := u.client.CoreV1().PersistentVolumes().Delete(pvName, &metav1.DeleteOptions{})
metrics.APIServerRequestsDurationSeconds.WithLabelValues(metrics.APIServ... | go | {
"resource": ""
} |
q25675 | NewFakeAPIUtil | train | func NewFakeAPIUtil(shouldFail bool, cache *cache.VolumeCache) *FakeAPIUtil {
return &FakeAPIUtil{
createdPVs: map[string]*v1.PersistentVolume{},
deletedPVs: map[string]*v1.PersistentVolume{},
CreatedJobs: map[string]*batch_v1.Job{},
DeletedJobs: map[string]string{},
shouldFail: shouldFail,
cache: ... | go | {
"resource": ""
} |
q25676 | CreatePV | train | func (u *FakeAPIUtil) CreatePV(pv *v1.PersistentVolume) (*v1.PersistentVolume, error) {
if u.shouldFail {
return nil, fmt.Errorf("API failed")
}
u.createdPVs[pv.Name] = pv
u.cache.AddPV(pv)
return pv, nil
} | go | {
"resource": ""
} |
q25677 | DeletePV | train | func (u *FakeAPIUtil) DeletePV(pvName string) error {
if u.shouldFail {
return fmt.Errorf("API failed")
}
pv, exists := u.cache.GetPV(pvName)
if exists {
u.deletedPVs[pvName] = pv
delete(u.createdPVs, pvName)
u.cache.DeletePV(pvName)
return nil
}
return errors.NewNotFound(v1.Resource("persistentvolumes... | go | {
"resource": ""
} |
q25678 | GetAndResetCreatedPVs | train | func (u *FakeAPIUtil) GetAndResetCreatedPVs() map[string]*v1.PersistentVolume {
createdPVs := u.createdPVs
u.createdPVs = map[string]*v1.PersistentVolume{}
return createdPVs
} | go | {
"resource": ""
} |
q25679 | GetAndResetDeletedPVs | train | func (u *FakeAPIUtil) GetAndResetDeletedPVs() map[string]*v1.PersistentVolume {
deletedPVs := u.deletedPVs
u.deletedPVs = map[string]*v1.PersistentVolume{}
return deletedPVs
} | go | {
"resource": ""
} |
q25680 | CreateJob | train | func (u *FakeAPIUtil) CreateJob(job *batch_v1.Job) error {
u.CreatedJobs[job.Namespace+"/"+job.Name] = job
return nil
} | go | {
"resource": ""
} |
q25681 | DeleteJob | train | func (u *FakeAPIUtil) DeleteJob(jobName string, namespace string) error {
u.DeletedJobs[namespace+"/"+jobName] = jobName
return nil
} | go | {
"resource": ""
} |
q25682 | getInstancesByRegex | train | func (c *Cloud) getInstancesByRegex(regex string) ([]types.NodeName, error) {
filters := []*ec2.Filter{newEc2Filter("instance-state-name", "running")}
instances, err := c.describeInstances(filters)
if err != nil {
return []types.NodeName{}, err
}
if len(instances) == 0 {
return []types.NodeName{}, fmt.Errorf... | go | {
"resource": ""
} |
q25683 | getMountDevice | train | func (c *Cloud) getMountDevice(
i *awsInstance,
info *ec2.Instance,
volumeID awsVolumeID,
assign bool) (assigned mountDevice, alreadyAttached bool, err error) {
instanceType := i.getInstanceType()
if instanceType == nil {
return "", false, fmt.Errorf("could not get instance type for instance: %s", i.awsID)
}
... | go | {
"resource": ""
} |
q25684 | describeVolume | train | func (d *awsDisk) describeVolume() (*ec2.Volume, error) {
volumeID := d.awsID
request := &ec2.DescribeVolumesInput{
VolumeIds: []*string{volumeID.awsString()},
}
volumes, err := d.ec2.DescribeVolumes(request)
if err != nil {
return nil, fmt.Errorf("error querying ec2 for volume %q: %v", volumeID, err)
}
if... | go | {
"resource": ""
} |
q25685 | waitForAttachmentStatus | train | func (d *awsDisk) waitForAttachmentStatus(status string) (*ec2.VolumeAttachment, error) {
backoff := wait.Backoff{
Duration: volumeAttachmentStatusInitialDelay,
Factor: volumeAttachmentStatusFactor,
Steps: volumeAttachmentStatusSteps,
}
// Because of rate limiting, we often see errors from describeVolume... | go | {
"resource": ""
} |
q25686 | deleteVolume | train | func (d *awsDisk) deleteVolume() (bool, error) {
request := &ec2.DeleteVolumeInput{VolumeId: d.awsID.awsString()}
_, err := d.ec2.DeleteVolume(request)
if err != nil {
if awsError, ok := err.(awserr.Error); ok {
if awsError.Code() == "InvalidVolume.NotFound" {
return false, nil
}
if awsError.Code() ==... | go | {
"resource": ""
} |
q25687 | getAwsInstance | train | func (c *Cloud) getAwsInstance(nodeName types.NodeName) (*awsInstance, error) {
var awsInstance *awsInstance
if nodeName == "" {
awsInstance = c.selfAWSInstance
} else {
instance, err := c.getInstanceByNodeName(nodeName)
if err != nil {
return nil, err
}
awsInstance = newAWSInstance(c.ec2, instance)
}... | go | {
"resource": ""
} |
q25688 | GetVolumeLabels | train | func (c *Cloud) GetVolumeLabels(volumeName KubernetesVolumeID) (map[string]string, error) {
awsDisk, err := newAWSDisk(c, volumeName)
if err != nil {
return nil, err
}
info, err := awsDisk.describeVolume()
if err != nil {
return nil, err
}
labels := make(map[string]string)
az := aws.StringValue(info.Availab... | go | {
"resource": ""
} |
q25689 | DisksAreAttached | train | func (c *Cloud) DisksAreAttached(nodeDisks map[types.NodeName][]KubernetesVolumeID) (map[types.NodeName]map[KubernetesVolumeID]bool, error) {
attached := make(map[types.NodeName]map[KubernetesVolumeID]bool)
if len(nodeDisks) == 0 {
return attached, nil
}
dnsNameSlice := []string{}
for nodeName, diskNames := ra... | go | {
"resource": ""
} |
q25690 | CreateSnapshot | train | func (c *Cloud) CreateSnapshot(snapshotOptions *SnapshotOptions) (snapshotID string, status string, err error) {
request := &ec2.CreateSnapshotInput{}
request.VolumeId = aws.String(snapshotOptions.VolumeID)
request.DryRun = aws.Bool(false)
descriptions := "Created by Kubernetes for volume " + snapshotOptions.Volume... | go | {
"resource": ""
} |
q25691 | DeleteSnapshot | train | func (c *Cloud) DeleteSnapshot(snapshotID string) (bool, error) {
request := &ec2.DeleteSnapshotInput{}
request.SnapshotId = aws.String(snapshotID)
_, err := c.ec2.DeleteSnapshot(request)
if err != nil {
return false, err
}
return true, nil
} | go | {
"resource": ""
} |
q25692 | DescribeSnapshot | train | func (c *Cloud) DescribeSnapshot(snapshotID string) (status string, isCompleted bool, err error) {
request := &ec2.DescribeSnapshotsInput{
SnapshotIds: []*string{
aws.String(snapshotID),
},
}
result, err := c.ec2.DescribeSnapshots(request)
if err != nil {
return "", false, err
}
if len(result) != 1 {
r... | go | {
"resource": ""
} |
q25693 | FindSnapshot | train | func (c *Cloud) FindSnapshot(tags map[string]string) ([]string, []string, error) {
request := &ec2.DescribeSnapshotsInput{}
for k, v := range tags {
filter := &ec2.Filter{}
filter.SetName(k)
filter.SetValues([]*string{&v})
request.Filters = append(request.Filters, filter)
}
result, err := c.ec2.DescribeSn... | go | {
"resource": ""
} |
q25694 | findSecurityGroup | train | func (c *Cloud) findSecurityGroup(securityGroupID string) (*ec2.SecurityGroup, error) {
describeSecurityGroupsRequest := &ec2.DescribeSecurityGroupsInput{
GroupIds: []*string{&securityGroupID},
}
// We don't apply our tag filters because we are retrieving by ID
groups, err := c.ec2.DescribeSecurityGroups(describ... | go | {
"resource": ""
} |
q25695 | setSecurityGroupIngress | train | func (c *Cloud) setSecurityGroupIngress(securityGroupID string, permissions IPPermissionSet) (bool, error) {
group, err := c.findSecurityGroup(securityGroupID)
if err != nil {
glog.Warning("Error retrieving security group", err)
return false, err
}
if group == nil {
return false, fmt.Errorf("security group n... | go | {
"resource": ""
} |
q25696 | findSecurityGroupForInstance | train | func findSecurityGroupForInstance(instance *ec2.Instance, taggedSecurityGroups map[string]*ec2.SecurityGroup) (*ec2.GroupIdentifier, error) {
instanceID := aws.StringValue(instance.InstanceId)
var tagged []*ec2.GroupIdentifier
var untagged []*ec2.GroupIdentifier
for _, group := range instance.SecurityGroups {
gr... | go | {
"resource": ""
} |
q25697 | getInstanceByID | train | func (c *Cloud) getInstanceByID(instanceID string) (*ec2.Instance, error) {
instances, err := c.getInstancesByIDs([]*string{&instanceID})
if err != nil {
return nil, err
}
if len(instances) == 0 {
return nil, cloudprovider.ErrInstanceNotFound
}
if len(instances) > 1 {
return nil, fmt.Errorf("multiple insta... | go | {
"resource": ""
} |
q25698 | getInstanceByNodeName | train | func (c *Cloud) getInstanceByNodeName(nodeName types.NodeName) (*ec2.Instance, error) {
instance, err := c.findInstanceByNodeName(nodeName)
if err == nil && instance == nil {
return nil, cloudprovider.ErrInstanceNotFound
}
return instance, err
} | go | {
"resource": ""
} |
q25699 | NewGlusterfsProvisioner | train | func NewGlusterfsProvisioner(config *rest.Config, client kubernetes.Interface) controller.Provisioner {
klog.Infof("Creating NewGlusterfsProvisioner.")
return newGlusterfsProvisionerInternal(config, client)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.