Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "gce", "*", "Cloud", ")", "CurrentNodeName", "(", "hostname", "string", ")", "(", "types", ".", "NodeName", ",", "error", ")", "{", "return", "types", ".", "NodeName", "(", "hostname", ")", ",", "nil", "\n", "}" ]

[ "CurrentNodeName", "is", "an", "implementation", "of", "Instances", ".", "CurrentNodeName" ]

[ "func", "(", "gce", "*", "Cloud", ")", "GetAllZones", "(", ")", "(", "sets", ".", "String", ",", "error", ")", "{", "// Fast-path for non-multizone", "if", "len", "(", "gce", ".", "managedZones", ")", "==", "1", "{", "return", "sets", ".", "NewString", "(", "gce", ".", "managedZones", "...", ")", ",", "nil", "\n", "}", "\n\n", "// TODO: Caching, but this is currently only called when we are creating a volume,", "// which is a relatively infrequent operation, and this is only # zones API calls", "zones", ":=", "sets", ".", "NewString", "(", ")", "\n\n", "// TODO: Parallelize, although O(zones) so not too bad (N <= 3 typically)", "for", "_", ",", "zone", ":=", "range", "gce", ".", "managedZones", "{", "// We only retrieve one page in each zone - we only care about existence", "listCall", ":=", "gce", ".", "service", ".", "Instances", ".", "List", "(", "gce", ".", "projectID", ",", "zone", ")", "\n\n", "// No filter: We assume that a zone is either used or unused", "// We could only consider running nodes (like we do in List above),", "// but probably if instances are starting we still want to consider them.", "// I think we should wait until we have a reason to make the", "// call one way or the other; we 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 and the health of zones.", "// Just a minimal set of fields - we only care about existence", "listCall", "=", "listCall", ".", "Fields", "(", "\"", "\"", ")", "\n\n", "res", ",", "err", ":=", "listCall", ".", "Do", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "len", "(", "res", ".", "Items", ")", "!=", "0", "{", "zones", ".", "Insert", "(", "zone", ")", "\n", "}", "\n", "}", "\n\n", "return", "zones", ",", "nil", "\n", "}" ]

[ "GetAllZones", "returns", "all", "the", "zones", "in", "which", "nodes", "are", "running" ]

[ "func", "(", "gce", "*", "Cloud", ")", "ListRoutes", "(", "clusterName", "string", ")", "(", "[", "]", "*", "cloudprovider", ".", "Route", ",", "error", ")", "{", "var", "routes", "[", "]", "*", "cloudprovider", ".", "Route", "\n", "pageToken", ":=", "\"", "\"", "\n", "page", ":=", "0", "\n", "for", ";", "page", "==", "0", "||", "(", "pageToken", "!=", "\"", "\"", "&&", "page", "<", "maxPages", ")", ";", "page", "++", "{", "listCall", ":=", "gce", ".", "service", ".", "Routes", ".", "List", "(", "gce", ".", "projectID", ")", "\n\n", "prefix", ":=", "truncateClusterName", "(", "clusterName", ")", "\n", "listCall", "=", "listCall", ".", "Filter", "(", "\"", "\"", "+", "prefix", "+", "\"", "\"", ")", "\n", "if", "pageToken", "!=", "\"", "\"", "{", "listCall", "=", "listCall", ".", "PageToken", "(", "pageToken", ")", "\n", "}", "\n", "res", ",", "err", ":=", "listCall", ".", "Do", "(", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "pageToken", "=", "res", ".", "NextPageToken", "\n", "for", "_", ",", "r", ":=", "range", "res", ".", "Items", "{", "if", "r", ".", "Network", "!=", "gce", ".", "networkURL", "{", "continue", "\n", "}", "\n", "// Not managed if route description != \"k8s-node-route\"", "if", "r", ".", "Description", "!=", "k8sNodeRouteTag", "{", "continue", "\n", "}", "\n", "// Not managed if route name doesn't start with <clusterName>", "if", "!", "strings", ".", "HasPrefix", "(", "r", ".", "Name", ",", "prefix", ")", "{", "continue", "\n", "}", "\n\n", "target", ":=", "path", ".", "Base", "(", "r", ".", "NextHopInstance", ")", "\n", "// TODO: Should we lastComponent(target) this?", "targetNodeName", ":=", "types", ".", "NodeName", "(", "target", ")", "// NodeName == Instance Name on GCE", "\n", "routes", "=", "append", "(", "routes", ",", "&", "cloudprovider", ".", "Route", "{", "Name", ":", "r", ".", "Name", ",", "TargetNode", ":", "targetNodeName", ",", "DestinationCIDR", ":", "r", ".", "DestRange", "}", ")", "\n", "}", "\n", "}", "\n", "if", "page", ">=", "maxPages", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "maxPages", ")", "\n", "}", "\n", "return", "routes", ",", "nil", "\n", "}" ]

[ "ListRoutes", "lists", "routes" ]

[ "func", "(", "gce", "*", "Cloud", ")", "GetZone", "(", ")", "(", "cloudprovider", ".", "Zone", ",", "error", ")", "{", "return", "cloudprovider", ".", "Zone", "{", "FailureDomain", ":", "gce", ".", "localZone", ",", "Region", ":", "gce", ".", "region", ",", "}", ",", "nil", "\n", "}" ]

[ "GetZone", "gets", "a", "zone" ]

[ "func", "(", "gce", "*", "Cloud", ")", "DeleteDisk", "(", "diskToDelete", "string", ")", "error", "{", "err", ":=", "gce", ".", "doDeleteDisk", "(", "diskToDelete", ")", "\n", "if", "isGCEError", "(", "err", ",", "\"", "\"", ")", "{", "return", "volume", ".", "NewDeletedVolumeInUseError", "(", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "if", "err", "==", "cloudprovider", ".", "ErrDiskNotFound", "{", "return", "nil", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "DeleteDisk", "deletes", "a", "disk" ]

[ "func", "(", "gce", "*", "Cloud", ")", "AttachDisk", "(", "diskName", "string", ",", "nodeName", "types", ".", "NodeName", ",", "readOnly", "bool", ")", "error", "{", "instanceName", ":=", "mapNodeNameToInstanceName", "(", "nodeName", ")", "\n", "instance", ",", "err", ":=", "gce", ".", "getInstanceByName", "(", "instanceName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "instanceName", ")", "\n", "}", "\n", "disk", ",", "err", ":=", "gce", ".", "getDiskByName", "(", "diskName", ",", "instance", ".", "Zone", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "readWrite", ":=", "\"", "\"", "\n", "if", "readOnly", "{", "readWrite", "=", "\"", "\"", "\n", "}", "\n", "attachedDisk", ":=", "gce", ".", "convertDiskToAttachedDisk", "(", "disk", ",", "readWrite", ")", "\n\n", "attachOp", ",", "err", ":=", "gce", ".", "service", ".", "Instances", ".", "AttachDisk", "(", "gce", ".", "projectID", ",", "disk", ".", "Zone", ",", "instance", ".", "Name", ",", "attachedDisk", ")", ".", "Do", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "gce", ".", "waitForZoneOp", "(", "attachOp", ",", "disk", ".", "Zone", ")", "\n", "}" ]

[ "AttachDisk", "attaches", "a", "disk" ]

[ "func", "(", "gce", "*", "Cloud", ")", "DetachDisk", "(", "devicePath", "string", ",", "nodeName", "types", ".", "NodeName", ")", "error", "{", "instanceName", ":=", "mapNodeNameToInstanceName", "(", "nodeName", ")", "\n", "inst", ",", "err", ":=", "gce", ".", "getInstanceByName", "(", "instanceName", ")", "\n", "if", "err", "!=", "nil", "{", "if", "err", "==", "cloudprovider", ".", "ErrInstanceNotFound", "{", "// If instance no longer exists, safe to assume volume is not attached.", "glog", ".", "Warningf", "(", "\"", "\"", ",", "instanceName", ",", "devicePath", ")", "\n", "return", "nil", "\n", "}", "\n\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "instanceName", ")", "\n", "}", "\n\n", "detachOp", ",", "err", ":=", "gce", ".", "service", ".", "Instances", ".", "DetachDisk", "(", "gce", ".", "projectID", ",", "inst", ".", "Zone", ",", "inst", ".", "Name", ",", "devicePath", ")", ".", "Do", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "gce", ".", "waitForZoneOp", "(", "detachOp", ",", "inst", ".", "Zone", ")", "\n", "}" ]

[ "DetachDisk", "detaches", "a", "disk" ]

[ "func", "(", "gce", "*", "Cloud", ")", "DiskIsAttached", "(", "diskName", "string", ",", "nodeName", "types", ".", "NodeName", ")", "(", "bool", ",", "error", ")", "{", "instanceName", ":=", "mapNodeNameToInstanceName", "(", "nodeName", ")", "\n", "instance", ",", "err", ":=", "gce", ".", "getInstanceByName", "(", "instanceName", ")", "\n", "if", "err", "!=", "nil", "{", "if", "err", "==", "cloudprovider", ".", "ErrInstanceNotFound", "{", "// If instance no longer exists, safe to assume volume is not attached.", "glog", ".", "Warningf", "(", "\"", "\"", ",", "instanceName", ",", "diskName", ")", "\n", "return", "false", ",", "nil", "\n", "}", "\n\n", "return", "false", ",", "err", "\n", "}", "\n\n", "for", "_", ",", "disk", ":=", "range", "instance", ".", "Disks", "{", "if", "disk", ".", "DeviceName", "==", "diskName", "{", "// Disk is still attached to node", "return", "true", ",", "nil", "\n", "}", "\n", "}", "\n\n", "return", "false", ",", "nil", "\n", "}" ]

[ "DiskIsAttached", "checks", "if", "disk", "is", "attached" ]

[ "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.", "//", "// In future, we will have to require users to qualify their disk", "// \"us-central1-a/mydisk\". We could do this for them as part of", "// admission control, but that might be a little weird (values changing", "// on create)", "var", "found", "*", "gceDisk", "\n", "for", "_", ",", "zone", ":=", "range", "gce", ".", "managedZones", "{", "disk", ",", "err", ":=", "gce", ".", "findDiskByName", "(", "diskName", ",", "zone", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "// findDiskByName returns (nil,nil) if the disk doesn't exist, so we can't", "// assume that a disk was found unless disk is non-nil.", "if", "disk", "==", "nil", "{", "continue", "\n", "}", "\n", "if", "found", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "diskName", ")", "\n", "}", "\n", "found", "=", "disk", "\n", "}", "\n", "if", "found", "!=", "nil", "{", "return", "found", ",", "nil", "\n", "}", "\n", "glog", ".", "Warningf", "(", "\"", "\"", ",", "diskName", ",", "strings", ".", "Join", "(", "gce", ".", "managedZones", ",", "\"", "\"", ")", ")", "\n", "return", "nil", ",", "cloudprovider", ".", "ErrDiskNotFound", "\n", "}" ]

[ "Scans", "all", "managed", "zones", "to", "return", "the", "GCE", "PD", "Prefer", "getDiskByName", "if", "the", "zone", "can", "be", "established", "Return", "cloudprovider", ".", "ErrDiskNotFound", "if", "the", "given", "disk", "cannot", "be", "found", "in", "any", "zone" ]

[ "func", "(", "gce", "*", "Cloud", ")", "convertDiskToAttachedDisk", "(", "disk", "*", "gceDisk", ",", "readWrite", "string", ")", "*", "compute", ".", "AttachedDisk", "{", "return", "&", "compute", ".", "AttachedDisk", "{", "DeviceName", ":", "disk", ".", "Name", ",", "Kind", ":", "disk", ".", "Kind", ",", "Mode", ":", "readWrite", ",", "Source", ":", "\"", "\"", "+", "path", ".", "Join", "(", "\"", "\"", ",", "gce", ".", "projectID", ",", "\"", "\"", ",", "disk", ".", "Zone", ",", "\"", "\"", ",", "disk", ".", "Name", ")", ",", "Type", ":", "\"", "\"", ",", "}", "\n", "}" ]

[ "Converts", "a", "Disk", "resource", "to", "an", "AttachedDisk", "resource", "." ]

[ "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", "\n", "for", "_", ",", "managedZone", ":=", "range", "gce", ".", "managedZones", "{", "if", "zone", "==", "managedZone", "{", "isManaged", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "!", "isManaged", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "zone", ")", "\n", "}", "\n\n", "tagsStr", ",", "err", ":=", "gce", ".", "encodeDiskTags", "(", "tags", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "switch", "diskType", "{", "case", "DiskTypeSSD", ",", "DiskTypeStandard", ":", "// noop", "case", "\"", "\"", ":", "diskType", "=", "diskTypeDefault", "\n", "default", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "diskType", ")", "\n", "}", "\n", "diskTypeURI", ":=", "fmt", ".", "Sprintf", "(", "diskTypeURITemplate", ",", "gce", ".", "projectID", ",", "zone", ",", "diskType", ")", "\n\n", "snapshotName", ":=", "\"", "\"", "+", "snapshot", "\n", "diskToCreate", ":=", "&", "compute", ".", "Disk", "{", "Name", ":", "name", ",", "SizeGb", ":", "sizeGb", ",", "Description", ":", "tagsStr", ",", "Type", ":", "diskTypeURI", ",", "SourceSnapshot", ":", "snapshotName", ",", "}", "\n", "glog", ".", "Infof", "(", "\"", "\"", ",", "diskToCreate", ")", "\n", "createOp", ",", "err", ":=", "gce", ".", "service", ".", "Disks", ".", "Insert", "(", "gce", ".", "projectID", ",", "zone", ",", "diskToCreate", ")", ".", "Do", "(", ")", "\n", "glog", ".", "Infof", "(", "\"", "\"", ",", "createOp", ",", "err", ")", "\n", "if", "err", "!=", "nil", "{", "if", "isGCEError", "(", "err", ",", "\"", "\"", ")", "{", "glog", ".", "Warningf", "(", "\"", "\"", ",", "name", ")", "\n", "return", "nil", "\n", "}", "\n", "return", "err", "\n", "}", "\n\n", "err", "=", "gce", ".", "waitForZoneOp", "(", "createOp", ",", "zone", ")", "\n", "if", "isGCEError", "(", "err", ",", "\"", "\"", ")", "{", "glog", ".", "Warningf", "(", "\"", "\"", ",", "name", ")", "\n", "return", "nil", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "CreateDiskFromSnapshot", "create", "a", "disk", "from", "snapshot" ]

[ "func", "(", "gce", "*", "Cloud", ")", "DescribeSnapshot", "(", "snapshotToGet", "string", ")", "(", "status", "string", ",", "isCompleted", "bool", ",", "err", "error", ")", "{", "snapshot", ",", "err", ":=", "gce", ".", "getSnapshotByName", "(", "snapshotToGet", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "false", ",", "err", "\n", "}", "\n", "//no snapshot is found", "if", "snapshot", "==", "nil", "{", "return", "\"", "\"", ",", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "snapshotToGet", ")", "\n", "}", "\n", "if", "snapshot", ".", "Status", "==", "\"", "\"", "{", "return", "snapshot", ".", "Status", ",", "true", ",", "nil", "\n", "}", "\n", "return", "snapshot", ".", "Status", ",", "false", ",", "nil", "\n", "}" ]

[ "DescribeSnapshot", "checks", "the", "status", "of", "a", "snapshot" ]

[ "func", "(", "gce", "*", "Cloud", ")", "FindSnapshot", "(", "tags", "map", "[", "string", "]", "string", ")", "(", "[", "]", "string", ",", "[", "]", "string", ",", "error", ")", "{", "var", "snapshotIDs", ",", "statuses", "[", "]", "string", "\n", "return", "snapshotIDs", ",", "statuses", ",", "nil", "\n", "}" ]

[ "FindSnapshot", "returns", "the", "found", "snapshots" ]

[ "func", "(", "gce", "*", "Cloud", ")", "DeleteSnapshot", "(", "snapshotToDelete", "string", ")", "error", "{", "snapshot", ",", "err", ":=", "gce", ".", "getSnapshotByName", "(", "snapshotToDelete", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "//no snapshot is found", "if", "snapshot", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "deleteOp", ",", "err", ":=", "gce", ".", "service", ".", "Snapshots", ".", "Delete", "(", "gce", ".", "projectID", ",", "snapshotToDelete", ")", ".", "Do", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "gce", ".", "waitForGlobalOp", "(", "deleteOp", ")", "\n", "}" ]

[ "DeleteSnapshot", "deletes", "a", "snapshot" ]

[ "func", "(", "gce", "*", "Cloud", ")", "CreateSnapshot", "(", "diskName", "string", ",", "zone", "string", ",", "snapshotName", "string", ",", "tags", "map", "[", "string", "]", "string", ")", "error", "{", "isManaged", ":=", "false", "\n", "for", "_", ",", "managedZone", ":=", "range", "gce", ".", "managedZones", "{", "if", "zone", "==", "managedZone", "{", "isManaged", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "!", "isManaged", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "zone", ")", "\n", "}", "\n", "tagsStr", ",", "err", ":=", "gce", ".", "encodeDiskTags", "(", "tags", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Infof", "(", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "snapshotToCreate", ":=", "&", "compute", ".", "Snapshot", "{", "Name", ":", "snapshotName", ",", "Description", ":", "tagsStr", ",", "}", "\n", "glog", ".", "V", "(", "4", ")", ".", "Infof", "(", "\"", "\"", ",", "gce", ".", "projectID", ",", "zone", ",", "diskName", ",", "snapshotToCreate", ")", "\n", "createOp", ",", "err", ":=", "gce", ".", "service", ".", "Disks", ".", "CreateSnapshot", "(", "gce", ".", "projectID", ",", "zone", ",", "diskName", ",", "snapshotToCreate", ")", ".", "Do", "(", ")", "\n", "glog", ".", "V", "(", "4", ")", ".", "Infof", "(", "\"", "\"", ",", "createOp", ")", "\n", "return", "err", "\n", "}" ]

[ "CreateSnapshot", "creates", "a", "snapshot" ]

[ "func", "(", "gce", "*", "Cloud", ")", "ListClusters", "(", ")", "(", "[", "]", "string", ",", "error", ")", "{", "allClusters", ":=", "[", "]", "string", "{", "}", "\n\n", "for", "_", ",", "zone", ":=", "range", "gce", ".", "managedZones", "{", "clusters", ",", "err", ":=", "gce", ".", "listClustersInZone", "(", "zone", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "// TODO: Scoping? Do we need to qualify the cluster name?", "allClusters", "=", "append", "(", "allClusters", ",", "clusters", "...", ")", "\n", "}", "\n\n", "return", "allClusters", ",", "nil", "\n", "}" ]

[ "ListClusters", "lists", "clusters" ]

[ "func", "(", "gce", "*", "Cloud", ")", "getInstancesByNames", "(", "names", "[", "]", "string", ")", "(", "[", "]", "*", "gceInstance", ",", "error", ")", "{", "instances", ":=", "make", "(", "map", "[", "string", "]", "*", "gceInstance", ")", "\n", "remaining", ":=", "len", "(", "names", ")", "\n\n", "nodeInstancePrefix", ":=", "gce", ".", "nodeInstancePrefix", "\n", "for", "_", ",", "name", ":=", "range", "names", "{", "name", "=", "canonicalizeInstanceName", "(", "name", ")", "\n", "if", "!", "strings", ".", "HasPrefix", "(", "name", ",", "gce", ".", "nodeInstancePrefix", ")", "{", "glog", ".", "Warningf", "(", "\"", "\"", ",", "name", ",", "gce", ".", "nodeInstancePrefix", ")", "\n", "nodeInstancePrefix", "=", "\"", "\"", "\n", "}", "\n", "instances", "[", "name", "]", "=", "nil", "\n", "}", "\n\n", "for", "_", ",", "zone", ":=", "range", "gce", ".", "managedZones", "{", "if", "remaining", "==", "0", "{", "break", "\n", "}", "\n\n", "pageToken", ":=", "\"", "\"", "\n", "page", ":=", "0", "\n", "for", ";", "page", "==", "0", "||", "(", "pageToken", "!=", "\"", "\"", "&&", "page", "<", "maxPages", ")", ";", "page", "++", "{", "listCall", ":=", "gce", ".", "service", ".", "Instances", ".", "List", "(", "gce", ".", "projectID", ",", "zone", ")", "\n\n", "if", "nodeInstancePrefix", "!=", "\"", "\"", "{", "// Add the filter for hosts", "listCall", "=", "listCall", ".", "Filter", "(", "\"", "\"", "+", "nodeInstancePrefix", "+", "\"", "\"", ")", "\n", "}", "\n\n", "// TODO(zmerlynn): Internal bug 29524655", "// listCall = listCall.Fields(\"items(name,id,disks,machineType)\")", "if", "pageToken", "!=", "\"", "\"", "{", "listCall", ".", "PageToken", "(", "pageToken", ")", "\n", "}", "\n\n", "res", ",", "err", ":=", "listCall", ".", "Do", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "pageToken", "=", "res", ".", "NextPageToken", "\n", "for", "_", ",", "i", ":=", "range", "res", ".", "Items", "{", "name", ":=", "i", ".", "Name", "\n", "if", "_", ",", "ok", ":=", "instances", "[", "name", "]", ";", "!", "ok", "{", "continue", "\n", "}", "\n\n", "instance", ":=", "&", "gceInstance", "{", "Zone", ":", "zone", ",", "Name", ":", "name", ",", "ID", ":", "i", ".", "Id", ",", "Disks", ":", "i", ".", "Disks", ",", "Type", ":", "lastComponent", "(", "i", ".", "MachineType", ")", ",", "}", "\n", "instances", "[", "name", "]", "=", "instance", "\n", "remaining", "--", "\n", "}", "\n", "}", "\n", "if", "page", ">=", "maxPages", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "maxPages", ")", "\n", "}", "\n", "}", "\n\n", "instanceArray", ":=", "make", "(", "[", "]", "*", "gceInstance", ",", "len", "(", "names", ")", ")", "\n", "for", "i", ",", "name", ":=", "range", "names", "{", "name", "=", "canonicalizeInstanceName", "(", "name", ")", "\n", "instance", ":=", "instances", "[", "name", "]", "\n", "if", "instance", "==", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "name", ")", "\n", "return", "nil", ",", "cloudprovider", ".", "ErrInstanceNotFound", "\n", "}", "\n", "instanceArray", "[", "i", "]", "=", "instances", "[", "name", "]", "\n", "}", "\n\n", "return", "instanceArray", ",", "nil", "\n", "}" ]

[ "Gets", "the", "named", "instances", "returning", "cloudprovider", ".", "ErrInstanceNotFound", "if", "any", "instance", "is", "not", "found" ]

[ "func", "(", "gce", "*", "Cloud", ")", "getInstanceByName", "(", "name", "string", ")", "(", "*", "gceInstance", ",", "error", ")", "{", "// Avoid changing behaviour when not managing multiple zones", "for", "_", ",", "zone", ":=", "range", "gce", ".", "managedZones", "{", "name", "=", "canonicalizeInstanceName", "(", "name", ")", "\n", "res", ",", "err", ":=", "gce", ".", "service", ".", "Instances", ".", "Get", "(", "gce", ".", "projectID", ",", "zone", ",", "name", ")", ".", "Do", "(", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "name", ",", "err", ")", "\n", "if", "isHTTPErrorCode", "(", "err", ",", "http", ".", "StatusNotFound", ")", "{", "continue", "\n", "}", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "gceInstance", "{", "Zone", ":", "lastComponent", "(", "res", ".", "Zone", ")", ",", "Name", ":", "res", ".", "Name", ",", "ID", ":", "res", ".", "Id", ",", "Disks", ":", "res", ".", "Disks", ",", "Type", ":", "lastComponent", "(", "res", ".", "MachineType", ")", ",", "}", ",", "nil", "\n", "}", "\n\n", "return", "nil", ",", "cloudprovider", ".", "ErrInstanceNotFound", "\n", "}" ]

[ "Gets", "the", "named", "instance", "returning", "cloudprovider", ".", "ErrInstanceNotFound", "if", "the", "instance", "is", "not", "found" ]

[ "func", "(", "a", "Attrs", ")", "Set", "(", "name", "string", ",", "expr", "bzl", ".", "Expr", ")", "{", "a", "[", "name", "]", "=", "expr", "\n", "}" ]

[ "Set", "sets", "the", "named", "attribute", "to", "the", "provided", "bazel", "expression", "." ]

[ "func", "(", "a", "Attrs", ")", "SetList", "(", "name", "string", ",", "expr", "*", "bzl", ".", "ListExpr", ")", "{", "if", "len", "(", "expr", ".", "List", ")", "==", "0", "{", "return", "\n", "}", "\n", "a", "[", "name", "]", "=", "expr", "\n", "}" ]

[ "SetList", "sets", "the", "named", "attribute", "to", "the", "provided", "bazel", "expression", "list", "." ]

[ "func", "findBuildFile", "(", "pkgPath", "string", ")", "(", "bool", ",", "string", ")", "{", "options", ":=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", "}", "\n", "for", "_", ",", "b", ":=", "range", "options", "{", "path", ":=", "filepath", ".", "Join", "(", "pkgPath", ",", "b", ")", "\n", "info", ",", "err", ":=", "os", ".", "Stat", "(", "path", ")", "\n", "if", "err", "==", "nil", "&&", "!", "info", ".", "IsDir", "(", ")", "{", "return", "true", ",", "path", "\n", "}", "\n", "}", "\n", "return", "false", ",", "filepath", ".", "Join", "(", "pkgPath", ",", "\"", "\"", ")", "\n", "}" ]

[ "findBuildFile", "determines", "the", "name", "of", "a", "preexisting", "BUILD", "file", "returning", "a", "default", "if", "no", "such", "file", "exists", "." ]

[ "func", "ReconcileRules", "(", "pkgPath", "string", ",", "rules", "[", "]", "*", "bzl", ".", "Rule", ",", "managedAttrs", "[", "]", "string", ",", "dryRun", "bool", ")", "(", "bool", ",", "error", ")", "{", "_", ",", "path", ":=", "findBuildFile", "(", "pkgPath", ")", "\n", "info", ",", "err", ":=", "os", ".", "Stat", "(", "path", ")", "\n", "if", "err", "!=", "nil", "&&", "os", ".", "IsNotExist", "(", "err", ")", "{", "f", ":=", "&", "bzl", ".", "File", "{", "}", "\n", "writeHeaders", "(", "f", ")", "\n", "reconcileLoad", "(", "f", ",", "rules", ")", "\n", "writeRules", "(", "f", ",", "rules", ")", "\n", "return", "writeFile", "(", "path", ",", "f", ",", "false", ",", "dryRun", ")", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "if", "info", ".", "IsDir", "(", ")", "{", "return", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "path", ")", "\n", "}", "\n", "b", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "f", ",", "err", ":=", "bzl", ".", "Parse", "(", "path", ",", "b", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "oldRules", ":=", "make", "(", "map", "[", "string", "]", "*", "bzl", ".", "Rule", ")", "\n", "for", "_", ",", "r", ":=", "range", "f", ".", "Rules", "(", "\"", "\"", ")", "{", "oldRules", "[", "r", ".", "Name", "(", ")", "]", "=", "r", "\n", "}", "\n", "for", "_", ",", "r", ":=", "range", "rules", "{", "o", ",", "ok", ":=", "oldRules", "[", "r", ".", "Name", "(", ")", "]", "\n", "if", "!", "ok", "{", "f", ".", "Stmt", "=", "append", "(", "f", ".", "Stmt", ",", "r", ".", "Call", ")", "\n", "continue", "\n", "}", "\n", "if", "!", "RuleIsManaged", "(", "o", ")", "{", "continue", "\n", "}", "\n", "reconcileAttr", ":=", "func", "(", "o", ",", "n", "*", "bzl", ".", "Rule", ",", "name", "string", ")", "{", "if", "e", ":=", "n", ".", "Attr", "(", "name", ")", ";", "e", "!=", "nil", "{", "o", ".", "SetAttr", "(", "name", ",", "e", ")", "\n", "}", "else", "{", "o", ".", "DelAttr", "(", "name", ")", "\n", "}", "\n", "}", "\n", "for", "_", ",", "attr", ":=", "range", "managedAttrs", "{", "reconcileAttr", "(", "o", ",", "r", ",", "attr", ")", "\n", "}", "\n", "delete", "(", "oldRules", ",", "r", ".", "Name", "(", ")", ")", "\n", "}", "\n\n", "for", "_", ",", "r", ":=", "range", "oldRules", "{", "if", "!", "RuleIsManaged", "(", "r", ")", "{", "continue", "\n", "}", "\n", "f", ".", "DelRules", "(", "r", ".", "Kind", "(", ")", ",", "r", ".", "Name", "(", ")", ")", "\n", "}", "\n", "reconcileLoad", "(", "f", ",", "f", ".", "Rules", "(", "\"", "\"", ")", ")", "\n\n", "return", "writeFile", "(", "path", ",", "f", ",", "true", ",", "dryRun", ")", "\n", "}" ]

[ "ReconcileRules", "reconciles", "simplifies", "and", "writes", "the", "rules", "for", "the", "specified", "package", "adding", "additional", "dependency", "rules", "as", "needed", "." ]

[ "func", "RuleIsManaged", "(", "r", "*", "bzl", ".", "Rule", ")", "bool", "{", "var", "automanaged", "bool", "\n", "for", "_", ",", "tag", ":=", "range", "r", ".", "AttrStrings", "(", "\"", "\"", ")", "{", "if", "tag", "==", "automanagedTag", "{", "automanaged", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n", "return", "automanaged", "\n", "}" ]

[ "RuleIsManaged", "returns", "whether", "the", "provided", "rule", "is", "managed", "by", "this", "tool", "based", "on", "the", "tags", "set", "on", "the", "rule", "." ]

[ "func", "CloudProviders", "(", ")", "[", "]", "string", "{", "names", ":=", "[", "]", "string", "{", "}", "\n", "providersMutex", ".", "Lock", "(", ")", "\n", "defer", "providersMutex", ".", "Unlock", "(", ")", "\n", "for", "name", ":=", "range", "providers", "{", "names", "=", "append", "(", "names", ",", "name", ")", "\n", "}", "\n", "return", "names", "\n", "}" ]

[ "CloudProviders", "returns", "the", "name", "of", "all", "registered", "cloud", "providers", "in", "a", "string", "slice" ]

[ "func", "(", "u", "*", "volumeUtil", ")", "GetBlockCapacityByte", "(", "fullPath", "string", ")", "(", "int64", ",", "error", ")", "{", "file", ",", "err", ":=", "os", ".", "OpenFile", "(", "fullPath", ",", "os", ".", "O_RDONLY", ",", "0", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "defer", "file", ".", "Close", "(", ")", "\n\n", "var", "size", "int64", "\n", "// Get size of block device into 64 bit int.", "// Ref: http://www.microhowto.info/howto/get_the_size_of_a_linux_block_special_device_in_c.html", "if", "_", ",", "_", ",", "err", ":=", "unix", ".", "Syscall", "(", "unix", ".", "SYS_IOCTL", ",", "file", ".", "Fd", "(", ")", ",", "unix", ".", "BLKGETSIZE64", ",", "uintptr", "(", "unsafe", ".", "Pointer", "(", "&", "size", ")", ")", ")", ";", "err", "!=", "0", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "return", "size", ",", "err", "\n", "}" ]

[ "GetBlockCapacityByte", "returns", "capacity", "in", "bytes", "of", "a", "block", "device", ".", "fullPath", "is", "the", "pathname", "of", "block", "device", "." ]

[ "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", "{", "PersistentVolumeReclaimPolicy", ":", "config", ".", "ReclaimPolicy", ",", "Capacity", ":", "v1", ".", "ResourceList", "{", "v1", ".", "ResourceName", "(", "v1", ".", "ResourceStorage", ")", ":", "*", "resource", ".", "NewQuantity", "(", "int64", "(", "config", ".", "Capacity", ")", ",", "resource", ".", "BinarySI", ")", ",", "}", ",", "PersistentVolumeSource", ":", "v1", ".", "PersistentVolumeSource", "{", "Local", ":", "&", "v1", ".", "LocalVolumeSource", "{", "Path", ":", "config", ".", "HostPath", ",", "FSType", ":", "config", ".", "FsType", ",", "}", ",", "}", ",", "AccessModes", ":", "[", "]", "v1", ".", "PersistentVolumeAccessMode", "{", "v1", ".", "ReadWriteOnce", ",", "}", ",", "StorageClassName", ":", "config", ".", "StorageClass", ",", "VolumeMode", ":", "&", "config", ".", "VolumeMode", ",", "MountOptions", ":", "config", ".", "MountOptions", ",", "}", ",", "}", "\n", "if", "config", ".", "UseAlphaAPI", "{", "pv", ".", "ObjectMeta", ".", "Annotations", "[", "AlphaStorageNodeAffinityAnnotation", "]", "=", "config", ".", "AffinityAnn", "\n", "}", "else", "{", "pv", ".", "Spec", ".", "NodeAffinity", "=", "config", ".", "NodeAffinity", "\n", "}", "\n", "return", "pv", "\n", "}" ]

[ "CreateLocalPVSpec", "returns", "a", "PV", "spec", "that", "can", "be", "used", "for", "PV", "creation" ]

[ "func", "GetVolumeConfigFromConfigMap", "(", "client", "*", "kubernetes", ".", "Clientset", ",", "namespace", ",", "name", "string", ",", "provisionerConfig", "*", "ProvisionerConfiguration", ")", "error", "{", "configMap", ",", "err", ":=", "client", ".", "CoreV1", "(", ")", ".", "ConfigMaps", "(", "namespace", ")", ".", "Get", "(", "name", ",", "metav1", ".", "GetOptions", "{", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "err", "=", "ConfigMapDataToVolumeConfig", "(", "configMap", ".", "Data", ",", "provisionerConfig", ")", "\n", "return", "err", "\n", "}" ]

[ "GetVolumeConfigFromConfigMap", "gets", "volume", "configuration", "from", "given", "configmap", "." ]

[ "func", "VolumeConfigToConfigMapData", "(", "config", "*", "ProvisionerConfiguration", ")", "(", "map", "[", "string", "]", "string", ",", "error", ")", "{", "configMapData", ":=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "val", ",", "err", ":=", "yaml", ".", "Marshal", "(", "config", ".", "StorageClassConfig", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "configMapData", "[", "ProvisonerStorageClassConfig", "]", "=", "string", "(", "val", ")", "\n", "if", "len", "(", "config", ".", "NodeLabelsForPV", ")", ">", "0", "{", "nodeLabels", ",", "nlErr", ":=", "yaml", ".", "Marshal", "(", "config", ".", "NodeLabelsForPV", ")", "\n", "if", "nlErr", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "nlErr", ")", "\n", "}", "\n", "configMapData", "[", "ProvisionerNodeLabelsForPV", "]", "=", "string", "(", "nodeLabels", ")", "\n", "}", "\n", "ver", ",", "err", ":=", "yaml", ".", "Marshal", "(", "config", ".", "UseAlphaAPI", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "configMapData", "[", "ProvisionerUseAlphaAPI", "]", "=", "string", "(", "ver", ")", "\n\n", "return", "configMapData", ",", "nil", "\n", "}" ]

[ "VolumeConfigToConfigMapData", "converts", "volume", "config", "to", "configmap", "data", "." ]

[ "func", "ConfigMapDataToVolumeConfig", "(", "data", "map", "[", "string", "]", "string", ",", "provisionerConfig", "*", "ProvisionerConfiguration", ")", "error", "{", "rawYaml", ":=", "\"", "\"", "\n", "for", "key", ",", "val", ":=", "range", "data", "{", "rawYaml", "+=", "key", "\n", "rawYaml", "+=", "\"", "\\n", "\"", "\n", "rawYaml", "+=", "insertSpaces", "(", "string", "(", "val", ")", ")", "\n", "}", "\n\n", "if", "err", ":=", "yaml", ".", "Unmarshal", "(", "[", "]", "byte", "(", "rawYaml", ")", ",", "provisionerConfig", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "for", "class", ",", "config", ":=", "range", "provisionerConfig", ".", "StorageClassConfig", "{", "if", "config", ".", "BlockCleanerCommand", "==", "nil", "{", "// Supply a default block cleaner command.", "config", ".", "BlockCleanerCommand", "=", "[", "]", "string", "{", "DefaultBlockCleanerCommand", "}", "\n", "}", "else", "{", "// Validate that array is non empty.", "if", "len", "(", "config", ".", "BlockCleanerCommand", ")", "<", "1", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "class", ")", "\n", "}", "\n", "}", "\n", "if", "config", ".", "MountDir", "==", "\"", "\"", "||", "config", ".", "HostDir", "==", "\"", "\"", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "class", ")", "\n", "}", "\n\n", "if", "config", ".", "VolumeMode", "==", "\"", "\"", "{", "config", ".", "VolumeMode", "=", "DefaultVolumeMode", "\n", "}", "\n", "volumeMode", ":=", "v1", ".", "PersistentVolumeMode", "(", "config", ".", "VolumeMode", ")", "\n", "if", "volumeMode", "!=", "v1", ".", "PersistentVolumeBlock", "&&", "volumeMode", "!=", "v1", ".", "PersistentVolumeFilesystem", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "config", ".", "VolumeMode", ")", "\n", "}", "\n\n", "provisionerConfig", ".", "StorageClassConfig", "[", "class", "]", "=", "config", "\n", "glog", ".", "Infof", "(", "\"", "\"", ",", "class", ",", "config", ".", "MountDir", ",", "config", ".", "HostDir", ",", "config", ".", "VolumeMode", ",", "config", ".", "FsType", ",", "config", ".", "BlockCleanerCommand", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ConfigMapDataToVolumeConfig", "converts", "configmap", "data", "to", "volume", "config", "." ]

[ "func", "LoadProvisionerConfigs", "(", "configPath", "string", ",", "provisionerConfig", "*", "ProvisionerConfiguration", ")", "error", "{", "files", ",", "err", ":=", "ioutil", ".", "ReadDir", "(", "configPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "data", ":=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "for", "_", ",", "file", ":=", "range", "files", "{", "if", "!", "file", ".", "IsDir", "(", ")", "{", "if", "strings", ".", "Compare", "(", "file", ".", "Name", "(", ")", ",", "\"", "\"", ")", "!=", "0", "{", "fileContents", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "path", ".", "Join", "(", "configPath", ",", "file", ".", "Name", "(", ")", ")", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Infof", "(", "\"", "\"", ",", "path", ".", "Join", "(", "configPath", ",", "file", ".", "Name", "(", ")", ")", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "data", "[", "file", ".", "Name", "(", ")", "]", "=", "string", "(", "fileContents", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "ConfigMapDataToVolumeConfig", "(", "data", ",", "provisionerConfig", ")", "\n", "}" ]

[ "LoadProvisionerConfigs", "loads", "all", "configuration", "into", "a", "string", "and", "unmarshal", "it", "into", "ProvisionerConfiguration", "struct", ".", "The", "configuration", "is", "stored", "in", "the", "configmap", "which", "is", "mounted", "as", "a", "volume", "." ]

[ "func", "SetupClient", "(", ")", "*", "kubernetes", ".", "Clientset", "{", "var", "config", "*", "rest", ".", "Config", "\n", "var", "err", "error", "\n\n", "kubeconfigFile", ":=", "os", ".", "Getenv", "(", "KubeConfigEnv", ")", "\n", "if", "kubeconfigFile", "!=", "\"", "\"", "{", "config", ",", "err", "=", "BuildConfigFromFlags", "(", "\"", "\"", ",", "kubeconfigFile", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Fatalf", "(", "\"", "\\n", "\"", ",", "KubeConfigEnv", ",", "kubeconfigFile", ",", "err", ")", "\n", "}", "\n", "glog", ".", "Infof", "(", "\"", "\"", ",", "kubeconfigFile", ")", "\n", "}", "else", "{", "config", ",", "err", "=", "InClusterConfig", "(", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Fatalf", "(", "\"", "\\n", "\"", ",", "err", ")", "\n", "}", "\n", "glog", ".", "Infof", "(", "\"", "\"", ")", "\n", "}", "\n\n", "clientset", ",", "err", ":=", "kubernetes", ".", "NewForConfig", "(", "config", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Fatalf", "(", "\"", "\\n", "\"", ",", "err", ")", "\n", "}", "\n", "return", "clientset", "\n", "}" ]

[ "SetupClient", "created", "client", "using", "either", "in", "-", "cluster", "configuration", "or", "if", "KUBECONFIG", "environment", "variable", "is", "specified", "then", "using", "that", "config", "." ]

[ "func", "GenerateMountName", "(", "mount", "*", "MountConfig", ")", "string", "{", "h", ":=", "fnv", ".", "New32a", "(", ")", "\n", "h", ".", "Write", "(", "[", "]", "byte", "(", "mount", ".", "HostDir", ")", ")", "\n", "h", ".", "Write", "(", "[", "]", "byte", "(", "mount", ".", "MountDir", ")", ")", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "h", ".", "Sum32", "(", ")", ")", "\n", "}" ]

[ "GenerateMountName", "generates", "a", "volumeMount", ".", "name", "for", "pod", "spec", "based", "on", "volume", "configuration", "." ]

[ "func", "GetVolumeMode", "(", "volUtil", "util", ".", "VolumeUtil", ",", "fullPath", "string", ")", "(", "v1", ".", "PersistentVolumeMode", ",", "error", ")", "{", "isdir", ",", "errdir", ":=", "volUtil", ".", "IsDir", "(", "fullPath", ")", "\n", "if", "isdir", "{", "return", "v1", ".", "PersistentVolumeFilesystem", ",", "nil", "\n", "}", "\n", "// check for Block before returning errdir", "isblk", ",", "errblk", ":=", "volUtil", ".", "IsBlock", "(", "fullPath", ")", "\n", "if", "isblk", "{", "return", "v1", ".", "PersistentVolumeBlock", ",", "nil", "\n", "}", "\n\n", "if", "errdir", "==", "nil", "&&", "errblk", "==", "nil", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "fullPath", ")", "\n", "}", "\n\n", "// report the first error found", "if", "errdir", "!=", "nil", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "fullPath", ",", "errdir", ")", "\n", "}", "\n", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "fullPath", ",", "errblk", ")", "\n", "}" ]

[ "GetVolumeMode", "check", "volume", "mode", "of", "given", "path", "." ]

[ "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", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "volume", ".", "Name", ",", "err", ")", "\n", "}", "\n", "if", "!", "provisioned", "{", "strerr", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "p", ".", "identity", ",", "volume", ".", "Name", ",", "volume", ".", "Annotations", "[", "annProvisionerID", "]", ")", "\n", "return", "&", "controller", ".", "IgnoredError", "{", "Reason", ":", "strerr", "}", "\n", "}", "\n\n", "err", "=", "p", ".", "deleteDirectory", "(", "volume", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "err", "=", "p", ".", "deleteExport", "(", "volume", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "err", "=", "p", ".", "deleteQuota", "(", "volume", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Delete", "removes", "the", "directory", "that", "was", "created", "by", "Provision", "backing", "the", "given", "PV", "and", "removes", "its", "export", "from", "the", "NFS", "server", "." ]

[ "func", "NewDigitalOceanProvisioner", "(", "ctx", "context", ".", "Context", ",", "client", "kubernetes", ".", "Interface", ",", "doClient", "*", "godo", ".", "Client", ")", "controller", ".", "Provisioner", "{", "var", "identity", "types", ".", "UID", "\n\n", "provisioner", ":=", "&", "digitaloceanProvisioner", "{", "client", ":", "client", ",", "doClient", ":", "doClient", ",", "ctx", ":", "ctx", ",", "identity", ":", "identity", ",", "}", "\n\n", "return", "provisioner", "\n", "}" ]

[ "NewDigitalOceanProvisioner", "creates", "a", "new", "DigitalOcean", "provisioner" ]

[ "func", "(", "p", "*", "iscsiProvisioner", ")", "getAccessModes", "(", ")", "[", "]", "v1", ".", "PersistentVolumeAccessMode", "{", "return", "[", "]", "v1", ".", "PersistentVolumeAccessMode", "{", "v1", ".", "ReadWriteOnce", ",", "v1", ".", "ReadOnlyMany", ",", "}", "\n", "}" ]

[ "getAccessModes", "returns", "access", "modes", "iscsi", "volume", "supported", "." ]

[ "func", "getFirstAvailableLun", "(", "exportList", "exportList", ")", "(", "int32", ",", "error", ")", "{", "sort", ".", "Sort", "(", "exportList", ")", "\n", "log", ".", "Debug", "(", "\"", "\"", ",", "exportList", ")", "\n", "//this is sloppy way to remove duplicates", "uniqueExport", ":=", "make", "(", "map", "[", "int32", "]", "export", ")", "\n", "for", "_", ",", "export", ":=", "range", "exportList", "{", "uniqueExport", "[", "export", ".", "Lun", "]", "=", "export", "\n", "}", "\n", "log", ".", "Debug", "(", "\"", "\"", ",", "uniqueExport", ")", "\n\n", "//this is a sloppy way to get the list of luns", "luns", ":=", "make", "(", "[", "]", "int", ",", "len", "(", "uniqueExport", ")", ",", "len", "(", "uniqueExport", ")", ")", "\n", "i", ":=", "0", "\n", "for", "_", ",", "export", ":=", "range", "uniqueExport", "{", "luns", "[", "i", "]", "=", "int", "(", "export", ".", "Lun", ")", "\n", "i", "++", "\n", "}", "\n", "log", ".", "Debug", "(", "\"", "\"", ",", "luns", ")", "\n\n", "if", "len", "(", "luns", ")", ">=", "255", "{", "return", "-", "1", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "var", "sluns", "sort", ".", "IntSlice", "\n", "sluns", "=", "luns", "[", "0", ":", "]", "\n", "sort", ".", "Sort", "(", "sluns", ")", "\n", "log", ".", "Debug", "(", "\"", "\"", ",", "sluns", ")", "\n\n", "lun", ":=", "int32", "(", "len", "(", "sluns", ")", ")", "\n", "for", "i", ",", "clun", ":=", "range", "sluns", "{", "if", "i", "<", "int", "(", "clun", ")", "{", "lun", "=", "int32", "(", "i", ")", "\n", "break", "\n", "}", "\n", "}", "\n", "return", "lun", ",", "nil", "\n", "}" ]

[ "getFirstAvailableLun", "gets", "first", "available", "Lun", "." ]

[ "func", "(", "p", "*", "iscsiProvisioner", ")", "volDestroy", "(", "vol", "string", ",", "pool", "string", ")", "error", "{", "client", ",", "err", ":=", "p", ".", "getConnection", "(", ")", "\n", "defer", "client", ".", "Close", "(", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warnln", "(", "err", ")", "\n", "return", "err", "\n", "}", "\n", "args", ":=", "volDestroyArgs", "{", "Pool", ":", "pool", ",", "Name", ":", "vol", ",", "}", "\n", "err", "=", "client", ".", "Call", "(", "\"", "\"", ",", "args", ",", "nil", ")", "\n", "return", "err", "\n", "}" ]

[ "volDestroy", "removes", "calls", "vol_destroy", "targetd", "API", "to", "remove", "volume", "." ]

[ "func", "(", "p", "*", "iscsiProvisioner", ")", "exportDestroy", "(", "vol", "string", ",", "pool", "string", ",", "initiator", "string", ")", "error", "{", "client", ",", "err", ":=", "p", ".", "getConnection", "(", ")", "\n", "defer", "client", ".", "Close", "(", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warnln", "(", "err", ")", "\n", "return", "err", "\n", "}", "\n", "args", ":=", "exportDestroyArgs", "{", "Pool", ":", "pool", ",", "Vol", ":", "vol", ",", "InitiatorWwn", ":", "initiator", ",", "}", "\n", "err", "=", "client", ".", "Call", "(", "\"", "\"", ",", "args", ",", "nil", ")", "\n", "return", "err", "\n", "}" ]

[ "exportDestroy", "calls", "export_destroy", "targetd", "API", "to", "remove", "export", "of", "volume", "." ]

[ "func", "(", "p", "*", "iscsiProvisioner", ")", "volCreate", "(", "name", "string", ",", "size", "int64", ",", "pool", "string", ")", "error", "{", "client", ",", "err", ":=", "p", ".", "getConnection", "(", ")", "\n", "defer", "client", ".", "Close", "(", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warnln", "(", "err", ")", "\n", "return", "err", "\n", "}", "\n", "args", ":=", "volCreateArgs", "{", "Pool", ":", "pool", ",", "Name", ":", "name", ",", "Size", ":", "size", ",", "}", "\n", "err", "=", "client", ".", "Call", "(", "\"", "\"", ",", "args", ",", "nil", ")", "\n", "return", "err", "\n", "}" ]

[ "volCreate", "calls", "vol_create", "targetd", "API", "to", "create", "a", "volume", "." ]

[ "func", "(", "p", "*", "iscsiProvisioner", ")", "exportCreate", "(", "vol", "string", ",", "lun", "int32", ",", "pool", "string", ",", "initiator", "string", ")", "error", "{", "client", ",", "err", ":=", "p", ".", "getConnection", "(", ")", "\n", "defer", "client", ".", "Close", "(", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warnln", "(", "err", ")", "\n", "return", "err", "\n", "}", "\n", "args", ":=", "exportCreateArgs", "{", "Pool", ":", "pool", ",", "Vol", ":", "vol", ",", "InitiatorWwn", ":", "initiator", ",", "Lun", ":", "lun", ",", "}", "\n", "err", "=", "client", ".", "Call", "(", "\"", "\"", ",", "args", ",", "nil", ")", "\n", "return", "err", "\n", "}" ]

[ "exportCreate", "calls", "export_create", "targetd", "API", "to", "create", "an", "export", "of", "volume", "." ]

[ "func", "(", "p", "*", "iscsiProvisioner", ")", "exportList", "(", ")", "(", "exportList", ",", "error", ")", "{", "client", ",", "err", ":=", "p", ".", "getConnection", "(", ")", "\n", "defer", "client", ".", "Close", "(", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warnln", "(", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "var", "result1", "exportList", "\n", "err", "=", "client", ".", "Call", "(", "\"", "\"", ",", "nil", ",", "&", "result1", ")", "\n", "return", "result1", ",", "err", "\n", "}" ]

[ "exportList", "lists", "calls", "export_list", "targetd", "API", "to", "get", "export", "objects", "." ]

[ "func", "(", "v", "*", "Vendorer", ")", "walkSource", "(", "pkgPath", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "// clean pkgPath since we access v.newRules directly", "pkgPath", "=", "filepath", ".", "Clean", "(", "pkgPath", ")", "\n", "for", "_", ",", "r", ":=", "range", "v", ".", "skippedPaths", "{", "if", "r", ".", "Match", "(", "[", "]", "byte", "(", "pkgPath", ")", ")", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "}", "\n", "files", ",", "err", ":=", "ioutil", ".", "ReadDir", "(", "pkgPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Find any children packages we need to include in an all-srcs rule.", "var", "children", "[", "]", "string", "\n", "for", "_", ",", "f", ":=", "range", "files", "{", "if", "f", ".", "IsDir", "(", ")", "{", "c", ",", "err", ":=", "v", ".", "walkSource", "(", "filepath", ".", "Join", "(", "pkgPath", ",", "f", ".", "Name", "(", ")", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "children", "=", "append", "(", "children", ",", "c", "...", ")", "\n", "}", "\n", "}", "\n\n", "// This path is a package either if we've added rules or if a BUILD file already exists.", "_", ",", "hasRules", ":=", "v", ".", "newRules", "[", "pkgPath", "]", "\n", "isPkg", ":=", "hasRules", "\n", "if", "!", "isPkg", "{", "isPkg", ",", "_", "=", "findBuildFile", "(", "pkgPath", ")", "\n", "}", "\n\n", "if", "!", "isPkg", "{", "// This directory isn't a package (doesn't contain a BUILD file),", "// but there might be subdirectories that are packages,", "// so pass that up to our parent.", "return", "children", ",", "nil", "\n", "}", "\n\n", "// Enforce formatting the BUILD file, even if we're not adding srcs rules", "if", "!", "hasRules", "{", "v", ".", "addRules", "(", "pkgPath", ",", "nil", ")", "\n", "}", "\n\n", "if", "!", "v", ".", "cfg", ".", "AddSourcesRules", "{", "return", "nil", ",", "nil", "\n", "}", "\n\n", "pkgSrcsExpr", ":=", "&", "bzl", ".", "LiteralExpr", "{", "Token", ":", "`glob([\"**\"])`", "}", "\n", "if", "pkgPath", "==", "\"", "\"", "{", "pkgSrcsExpr", "=", "&", "bzl", ".", "LiteralExpr", "{", "Token", ":", "`glob([\"**\"], exclude=[\"bazel-*/**\", \".git/**\"])`", "}", "\n", "}", "\n\n", "v", ".", "addRules", "(", "pkgPath", ",", "[", "]", "*", "bzl", ".", "Rule", "{", "newRule", "(", "RuleTypeFileGroup", ",", "func", "(", "_", "ruleType", ")", "string", "{", "return", "pkgSrcsTarget", "}", ",", "map", "[", "string", "]", "bzl", ".", "Expr", "{", "\"", "\"", ":", "pkgSrcsExpr", ",", "\"", "\"", ":", "asExpr", "(", "[", "]", "string", "{", "\"", "\"", "}", ")", ",", "}", ")", ",", "newRule", "(", "RuleTypeFileGroup", ",", "func", "(", "_", "ruleType", ")", "string", "{", "return", "allSrcsTarget", "}", ",", "map", "[", "string", "]", "bzl", ".", "Expr", "{", "\"", "\"", ":", "asExpr", "(", "append", "(", "children", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "pkgSrcsTarget", ")", ")", ")", ",", "}", ")", ",", "}", ")", "\n", "return", "[", "]", "string", "{", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "pkgPath", ",", "allSrcsTarget", ")", "}", ",", "nil", "\n", "}" ]

[ "walkSource", "walks", "the", "source", "tree", "recursively", "from", "pkgPath", "adding", "any", "BUILD", "files", "to", "v", ".", "newRules", "to", "be", "formatted", ".", "If", "AddSourcesRules", "is", "enabled", "in", "the", "kazel", "config", "then", "we", "additionally", "add", "package", "-", "sources", "and", "recursive", "all", "-", "srcs", "filegroups", "rules", "to", "every", "BUILD", "file", ".", "Returns", "the", "list", "of", "children", "all", "-", "srcs", "targets", "that", "should", "be", "added", "to", "the", "all", "-", "srcs", "rule", "of", "the", "enclosing", "package", "." ]

[ "func", "(", "os", "*", "OpenStack", ")", "NewNetworkV2", "(", ")", "(", "*", "gophercloud", ".", "ServiceClient", ",", "error", ")", "{", "network", ",", "err", ":=", "openstack", ".", "NewNetworkV2", "(", "os", ".", "provider", ",", "gophercloud", ".", "EndpointOpts", "{", "Region", ":", "os", ".", "region", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "return", "network", ",", "nil", "\n", "}" ]

[ "NewNetworkV2", "creates", "a", "new", "Network", "V2", "endpoint" ]

[ "func", "(", "os", "*", "OpenStack", ")", "NewComputeV2", "(", ")", "(", "*", "gophercloud", ".", "ServiceClient", ",", "error", ")", "{", "compute", ",", "err", ":=", "openstack", ".", "NewComputeV2", "(", "os", ".", "provider", ",", "gophercloud", ".", "EndpointOpts", "{", "Region", ":", "os", ".", "region", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "return", "compute", ",", "nil", "\n", "}" ]

[ "NewComputeV2", "creates", "a", "new", "Compute", "V2", "endpoint" ]

[ "func", "(", "os", "*", "OpenStack", ")", "OperationPending", "(", "diskName", "string", ")", "(", "bool", ",", "string", ",", "error", ")", "{", "volume", ",", "err", ":=", "os", ".", "getVolume", "(", "diskName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "\"", "\"", ",", "err", "\n", "}", "\n", "volumeStatus", ":=", "volume", ".", "Status", "\n", "if", "volumeStatus", "==", "VolumeErrorStatus", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "diskName", ",", "volumeStatus", ")", "\n", "return", "false", ",", "volumeStatus", ",", "nil", "\n", "}", "\n", "if", "volumeStatus", "==", "VolumeAvailableStatus", "||", "volumeStatus", "==", "VolumeInUseStatus", "||", "volumeStatus", "==", "VolumeDeletedStatus", "{", "return", "false", ",", "volume", ".", "Status", ",", "nil", "\n", "}", "\n", "return", "true", ",", "volumeStatus", ",", "nil", "\n", "}" ]

[ "OperationPending", "checks", "status", "makes", "sure", "we", "re", "not", "in", "error", "state" ]

[ "func", "(", "os", "*", "OpenStack", ")", "AttachDisk", "(", "instanceID", ",", "volumeID", "string", ")", "(", "string", ",", "error", ")", "{", "volume", ",", "err", ":=", "os", ".", "getVolume", "(", "volumeID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "if", "volume", ".", "Status", "!=", "VolumeAvailableStatus", "{", "errmsg", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "volume", ".", "Name", ",", "volume", ".", "Status", ",", "VolumeAvailableStatus", ",", "instanceID", ")", "\n", "glog", ".", "Error", "(", "errmsg", ")", "\n", "return", "\"", "\"", ",", "errors", ".", "New", "(", "errmsg", ")", "\n", "}", "\n", "cClient", ",", "err", ":=", "os", ".", "NewComputeV2", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "if", "volume", ".", "AttachedServerID", "!=", "\"", "\"", "{", "if", "instanceID", "==", "volume", ".", "AttachedServerID", "{", "glog", ".", "V", "(", "4", ")", ".", "Infof", "(", "\"", "\"", ",", "volumeID", ",", "instanceID", ")", "\n", "return", "volume", ".", "ID", ",", "nil", "\n", "}", "\n", "glog", ".", "V", "(", "2", ")", ".", "Infof", "(", "\"", "\"", ",", "volumeID", ",", "volume", ".", "AttachedServerID", ")", "\n", "err", "=", "os", ".", "DetachDisk", "(", "volume", ".", "AttachedServerID", ",", "volumeID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "}", "\n\n", "// add read only flag here if possible spothanis", "_", ",", "err", "=", "volumeattach", ".", "Create", "(", "cClient", ",", "instanceID", ",", "&", "volumeattach", ".", "CreateOpts", "{", "VolumeID", ":", "volume", ".", "ID", ",", "}", ")", ".", "Extract", "(", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "volumeID", ",", "instanceID", ",", "err", ")", "\n", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "glog", ".", "V", "(", "2", ")", ".", "Infof", "(", "\"", "\"", ",", "volumeID", ",", "instanceID", ")", "\n", "return", "volume", ".", "ID", ",", "nil", "\n", "}" ]

[ "AttachDisk", "attaches", "specified", "cinder", "volume", "to", "the", "compute", "running", "kubelet" ]

[ "func", "(", "os", "*", "OpenStack", ")", "DeleteVolume", "(", "volumeID", "string", ")", "error", "{", "used", ",", "err", ":=", "os", ".", "diskIsUsed", "(", "volumeID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "used", "{", "msg", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "volumeID", ")", "\n", "return", "k8sVolume", ".", "NewDeletedVolumeInUseError", "(", "msg", ")", "\n", "}", "\n\n", "volumes", ",", "err", ":=", "os", ".", "volumeService", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "||", "volumes", "==", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "os", ".", "region", ")", "\n", "return", "err", "\n", "}", "\n\n", "err", "=", "volumes", ".", "deleteVolume", "(", "volumeID", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "volumeID", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n\n", "}" ]

[ "DeleteVolume", "deletes", "the", "specified", "volume" ]

[ "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", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "if", "volume", ".", "Status", "!=", "VolumeInUseStatus", "{", "errmsg", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "volume", ".", "Name", ",", "volume", ".", "Status", ")", "\n", "glog", ".", "Error", "(", "errmsg", ")", "\n", "return", "\"", "\"", ",", "errors", ".", "New", "(", "errmsg", ")", "\n", "}", "\n", "if", "volume", ".", "AttachedServerID", "!=", "\"", "\"", "{", "if", "instanceID", "==", "volume", ".", "AttachedServerID", "{", "// Attachment[0][\"device\"] points to the device path", "// see http://developer.openstack.org/api-ref-blockstorage-v1.html", "return", "volume", ".", "AttachedDevice", ",", "nil", "\n", "}", "\n", "errMsg", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "volumeID", ",", "volume", ".", "AttachedServerID", ")", "\n", "glog", ".", "Error", "(", "errMsg", ")", "\n", "return", "\"", "\"", ",", "errors", ".", "New", "(", "errMsg", ")", "\n", "}", "\n", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "volumeID", ")", "\n", "}" ]

[ "GetAttachmentDiskPath", "retrieves", "device", "path", "of", "attached", "volume", "to", "the", "compute", "running", "kubelet", "as", "known", "by", "cinder" ]

[ "func", "NewPopulator", "(", "config", "*", "common", ".", "RuntimeConfig", ")", "*", "Populator", "{", "p", ":=", "&", "Populator", "{", "RuntimeConfig", ":", "config", "}", "\n", "sharedInformer", ":=", "config", ".", "InformerFactory", ".", "Core", "(", ")", ".", "V1", "(", ")", ".", "PersistentVolumes", "(", ")", "\n", "sharedInformer", ".", "Informer", "(", ")", ".", "AddEventHandler", "(", "cache", ".", "ResourceEventHandlerFuncs", "{", "AddFunc", ":", "func", "(", "obj", "interface", "{", "}", ")", "{", "pv", ",", "ok", ":=", "obj", ".", "(", "*", "v1", ".", "PersistentVolume", ")", "\n", "if", "!", "ok", "{", "glog", ".", "Errorf", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "p", ".", "handlePVUpdate", "(", "pv", ")", "\n", "}", ",", "UpdateFunc", ":", "func", "(", "oldObj", ",", "newObj", "interface", "{", "}", ")", "{", "newPV", ",", "ok", ":=", "newObj", ".", "(", "*", "v1", ".", "PersistentVolume", ")", "\n", "if", "!", "ok", "{", "glog", ".", "Errorf", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "p", ".", "handlePVUpdate", "(", "newPV", ")", "\n", "}", ",", "DeleteFunc", ":", "func", "(", "obj", "interface", "{", "}", ")", "{", "pv", ",", "ok", ":=", "obj", ".", "(", "*", "v1", ".", "PersistentVolume", ")", "\n", "if", "!", "ok", "{", "glog", ".", "Errorf", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "p", ".", "handlePVDelete", "(", "pv", ")", "\n", "}", ",", "}", ")", "\n", "return", "p", "\n", "}" ]

[ "NewPopulator", "returns", "a", "Populator", "object", "to", "update", "the", "PV", "cache" ]

[ "func", "(", "u", "*", "volumeUtil", ")", "IsDir", "(", "fullPath", "string", ")", "(", "bool", ",", "error", ")", "{", "dir", ",", "err", ":=", "os", ".", "Open", "(", "fullPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "defer", "dir", ".", "Close", "(", ")", "\n\n", "stat", ",", "err", ":=", "dir", ".", "Stat", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n\n", "return", "stat", ".", "IsDir", "(", ")", ",", "nil", "\n", "}" ]

[ "IsDir", "checks", "if", "the", "given", "path", "is", "a", "directory" ]

[ "func", "(", "u", "*", "volumeUtil", ")", "ReadDir", "(", "fullPath", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "dir", ",", "err", ":=", "os", ".", "Open", "(", "fullPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "dir", ".", "Close", "(", ")", "\n\n", "files", ",", "err", ":=", "dir", ".", "Readdirnames", "(", "-", "1", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "files", ",", "nil", "\n", "}" ]

[ "ReadDir", "returns", "a", "list", "all", "the", "files", "under", "the", "given", "directory" ]

[ "func", "(", "u", "*", "volumeUtil", ")", "DeleteContents", "(", "fullPath", "string", ")", "error", "{", "dir", ",", "err", ":=", "os", ".", "Open", "(", "fullPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "dir", ".", "Close", "(", ")", "\n\n", "files", ",", "err", ":=", "dir", ".", "Readdirnames", "(", "-", "1", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "errList", ":=", "[", "]", "error", "{", "}", "\n", "for", "_", ",", "file", ":=", "range", "files", "{", "err", "=", "os", ".", "RemoveAll", "(", "filepath", ".", "Join", "(", "fullPath", ",", "file", ")", ")", "\n", "if", "err", "!=", "nil", "{", "errList", "=", "append", "(", "errList", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "return", "utilerrors", ".", "NewAggregate", "(", "errList", ")", "\n", "}" ]

[ "DeleteContents", "deletes", "all", "the", "contents", "under", "the", "given", "directory" ]

[ "func", "(", "u", "*", "volumeUtil", ")", "GetFsCapacityByte", "(", "fullPath", "string", ")", "(", "int64", ",", "error", ")", "{", "_", ",", "capacity", ",", "_", ",", "_", ",", "_", ",", "_", ",", "err", ":=", "fs", ".", "FsInfo", "(", "fullPath", ")", "\n", "return", "capacity", ",", "err", "\n", "}" ]

[ "GetFsCapacityByte", "returns", "capacity", "in", "bytes", "about", "a", "mounted", "filesystem", ".", "fullPath", "is", "the", "pathname", "of", "any", "file", "within", "the", "mounted", "filesystem", ".", "Capacity", "returned", "here", "is", "total", "capacity", "." ]

[ "func", "NewFakeVolumeUtil", "(", "deleteShouldFail", "bool", ",", "dirFiles", "map", "[", "string", "]", "[", "]", "*", "FakeDirEntry", ")", "*", "FakeVolumeUtil", "{", "return", "&", "FakeVolumeUtil", "{", "directoryFiles", ":", "dirFiles", ",", "deleteShouldFail", ":", "deleteShouldFail", ",", "}", "\n", "}" ]

[ "NewFakeVolumeUtil", "returns", "a", "VolumeUtil", "object", "for", "use", "in", "unit", "testing" ]

[ "func", "(", "u", "*", "FakeVolumeUtil", ")", "ReadDir", "(", "fullPath", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "fileNames", ":=", "[", "]", "string", "{", "}", "\n", "files", ",", "found", ":=", "u", ".", "directoryFiles", "[", "fullPath", "]", "\n", "if", "!", "found", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "fullPath", ")", "\n", "}", "\n", "for", "_", ",", "file", ":=", "range", "files", "{", "fileNames", "=", "append", "(", "fileNames", ",", "file", ".", "Name", ")", "\n", "}", "\n", "return", "fileNames", ",", "nil", "\n", "}" ]

[ "ReadDir", "returns", "the", "list", "of", "all", "files", "under", "the", "given", "directory" ]

[ "func", "(", "u", "*", "FakeVolumeUtil", ")", "DeleteContents", "(", "fullPath", "string", ")", "error", "{", "if", "u", ".", "deleteShouldFail", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "DeleteContents", "removes", "all", "the", "contents", "under", "the", "given", "directory" ]

[ "func", "(", "u", "*", "FakeVolumeUtil", ")", "GetFsCapacityByte", "(", "fullPath", "string", ")", "(", "int64", ",", "error", ")", "{", "return", "u", ".", "getDirEntryCapacity", "(", "fullPath", ",", "FakeEntryFile", ")", "\n", "}" ]

[ "GetFsCapacityByte", "returns", "capacity", "in", "byte", "about", "a", "mounted", "filesystem", "." ]

[ "func", "(", "u", "*", "FakeVolumeUtil", ")", "GetBlockCapacityByte", "(", "fullPath", "string", ")", "(", "int64", ",", "error", ")", "{", "return", "u", ".", "getDirEntryCapacity", "(", "fullPath", ",", "FakeEntryBlock", ")", "\n", "}" ]

[ "GetBlockCapacityByte", "returns", "the", "space", "in", "the", "specified", "block", "device", "." ]

[ "func", "(", "u", "*", "FakeVolumeUtil", ")", "AddNewDirEntries", "(", "mountDir", "string", ",", "dirFiles", "map", "[", "string", "]", "[", "]", "*", "FakeDirEntry", ")", "{", "for", "dir", ",", "files", ":=", "range", "dirFiles", "{", "mountedPath", ":=", "filepath", ".", "Join", "(", "mountDir", ",", "dir", ")", "\n", "curFiles", ":=", "u", ".", "directoryFiles", "[", "mountedPath", "]", "\n", "if", "curFiles", "==", "nil", "{", "curFiles", "=", "[", "]", "*", "FakeDirEntry", "{", "}", "\n", "}", "\n", "glog", ".", "Infof", "(", "\"", "\\n", "\"", ",", "dir", ",", "files", ")", "\n", "u", ".", "directoryFiles", "[", "mountedPath", "]", "=", "append", "(", "curFiles", ",", "files", "...", ")", "\n", "}", "\n", "}" ]

[ "AddNewDirEntries", "adds", "the", "given", "files", "to", "the", "current", "directory", "listing", "This", "is", "only", "for", "testing" ]

[ "func", "GetSupportedVolumeFromPVSpec", "(", "spec", "*", "core_v1", ".", "PersistentVolumeSpec", ")", "string", "{", "if", "spec", ".", "HostPath", "!=", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "if", "spec", ".", "AWSElasticBlockStore", "!=", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "if", "spec", ".", "GCEPersistentDisk", "!=", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "if", "spec", ".", "Cinder", "!=", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "if", "spec", ".", "Glusterfs", "!=", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "GetSupportedVolumeFromPVSpec", "gets", "supported", "volume", "from", "PV", "spec" ]

[ "func", "GetSupportedVolumeFromSnapshotDataSpec", "(", "spec", "*", "VolumeSnapshotDataSpec", ")", "string", "{", "if", "spec", ".", "HostPath", "!=", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "if", "spec", ".", "AWSElasticBlockStore", "!=", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "if", "spec", ".", "GCEPersistentDiskSnapshot", "!=", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "if", "spec", ".", "CinderSnapshot", "!=", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "if", "spec", ".", "GlusterSnapshotVolume", "!=", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "GetSupportedVolumeFromSnapshotDataSpec", "gets", "supported", "volume", "from", "snapshot", "data", "spec" ]

[ "func", "(", "v", "*", "VolumeSnapshot", ")", "UnmarshalJSON", "(", "data", "[", "]", "byte", ")", "error", "{", "tmp", ":=", "VolumeSnapshotCopy", "{", "}", "\n", "err", ":=", "json", ".", "Unmarshal", "(", "data", ",", "&", "tmp", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "tmp2", ":=", "VolumeSnapshot", "(", "tmp", ")", "\n", "*", "v", "=", "tmp2", "\n", "return", "nil", "\n", "}" ]

[ "UnmarshalJSON", "unmarshalls", "json", "data" ]

[ "func", "(", "os", "*", "OpenStack", ")", "CreateSnapshot", "(", "sourceVolumeID", ",", "name", ",", "description", "string", ",", "tags", "map", "[", "string", "]", "string", ")", "(", "string", ",", "string", ",", "error", ")", "{", "snapshots", ",", "err", ":=", "os", ".", "snapshotService", "(", ")", "\n", "if", "err", "!=", "nil", "||", "snapshots", "==", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "os", ".", "region", ")", "\n", "return", "\"", "\"", ",", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "sourceVolumeID", ",", "err", ")", "\n", "}", "\n\n", "opts", ":=", "SnapshotCreateOpts", "{", "VolumeID", ":", "sourceVolumeID", ",", "Name", ":", "name", ",", "Description", ":", "description", ",", "}", "\n", "if", "tags", "!=", "nil", "{", "opts", ".", "Metadata", "=", "tags", "\n", "}", "\n\n", "snapshotID", ",", "status", ",", "err", ":=", "snapshots", ".", "createSnapshot", "(", "opts", ")", "\n\n", "if", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "sourceVolumeID", ",", "err", ")", "\n", "return", "\"", "\"", ",", "\"", "\"", ",", "err", "\n", "}", "\n\n", "glog", ".", "Infof", "(", "\"", "\"", ",", "snapshotID", ",", "sourceVolumeID", ")", "\n", "return", "snapshotID", ",", "status", ",", "nil", "\n", "}" ]

[ "CreateSnapshot", "from", "the", "specified", "volume" ]

[ "func", "(", "os", "*", "OpenStack", ")", "DeleteSnapshot", "(", "snapshotID", "string", ")", "error", "{", "snapshots", ",", "err", ":=", "os", ".", "snapshotService", "(", ")", "\n", "if", "err", "!=", "nil", "||", "snapshots", "==", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "os", ".", "region", ")", "\n", "return", "err", "\n", "}", "\n\n", "err", "=", "snapshots", ".", "deleteSnapshot", "(", "snapshotID", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "snapshotID", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "DeleteSnapshot", "deletes", "the", "specified", "snapshot" ]

[ "func", "(", "os", "*", "OpenStack", ")", "FindSnapshot", "(", "tags", "map", "[", "string", "]", "string", ")", "(", "[", "]", "string", ",", "[", "]", "string", ",", "error", ")", "{", "var", "snapshotIDs", ",", "statuses", "[", "]", "string", "\n", "ss", ",", "err", ":=", "os", ".", "snapshotService", "(", ")", "\n", "if", "err", "!=", "nil", "||", "ss", "==", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "os", ".", "region", ")", "\n", "return", "snapshotIDs", ",", "statuses", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "tags", ",", "err", ")", "\n", "}", "\n\n", "opts", ":=", "SnapshotListOpts", "{", "}", "\n", "snapshots", ",", "err", ":=", "ss", ".", "listSnapshots", "(", "opts", ")", "\n\n", "if", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "snapshotIDs", ",", "statuses", ",", "err", "\n", "}", "\n", "glog", ".", "Infof", "(", "\"", "\"", ",", "len", "(", "snapshots", ")", ")", "\n\n", "glog", ".", "Infof", "(", "\"", "\"", ",", "tags", ")", "\n", "// Loop around to find the snapshot with the matching input metadata", "// NOTE(xyang): Metadata based filtering for snapshots is supported by Cinder volume API", "// microversion 3.21 and above. Currently the OpenStack Cloud Provider only supports V2.0.", "// Revisit this later when V3.0 is supported.", "for", "_", ",", "snapshot", ":=", "range", "snapshots", "{", "glog", ".", "Infof", "(", "\"", "\"", ",", "snapshot", ")", "\n", "namespaceVal", ",", "ok", ":=", "snapshot", ".", "Metadata", "[", "ctrlsnap", ".", "CloudSnapshotCreatedForVolumeSnapshotNamespaceTag", "]", "\n", "if", "ok", "{", "if", "tags", "[", "ctrlsnap", ".", "CloudSnapshotCreatedForVolumeSnapshotNamespaceTag", "]", "==", "namespaceVal", "{", "nameVal", ",", "ok", ":=", "snapshot", ".", "Metadata", "[", "ctrlsnap", ".", "CloudSnapshotCreatedForVolumeSnapshotNameTag", "]", "\n", "if", "ok", "{", "if", "tags", "[", "ctrlsnap", ".", "CloudSnapshotCreatedForVolumeSnapshotNameTag", "]", "==", "nameVal", "{", "uidVal", ",", "ok", ":=", "snapshot", ".", "Metadata", "[", "ctrlsnap", ".", "CloudSnapshotCreatedForVolumeSnapshotUIDTag", "]", "\n", "if", "ok", "{", "if", "tags", "[", "ctrlsnap", ".", "CloudSnapshotCreatedForVolumeSnapshotUIDTag", "]", "==", "uidVal", "{", "timeVal", ",", "ok", ":=", "snapshot", ".", "Metadata", "[", "ctrlsnap", ".", "CloudSnapshotCreatedForVolumeSnapshotTimestampTag", "]", "\n", "if", "ok", "{", "if", "tags", "[", "ctrlsnap", ".", "CloudSnapshotCreatedForVolumeSnapshotTimestampTag", "]", "==", "timeVal", "{", "snapshotIDs", "=", "append", "(", "snapshotIDs", ",", "snapshot", ".", "ID", ")", "\n", "statuses", "=", "append", "(", "statuses", ",", "snapshot", ".", "Status", ")", "\n", "glog", ".", "Infof", "(", "\"", "\"", ",", "snapshot", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "snapshotIDs", ",", "statuses", ",", "nil", "\n", "}" ]

[ "FindSnapshot", "finds", "snapshot", "by", "metadata" ]

[ "func", "ReadCfg", "(", "cfgPath", "string", ")", "(", "*", "Cfg", ",", "error", ")", "{", "b", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "cfgPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "var", "cfg", "Cfg", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "b", ",", "&", "cfg", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defaultCfg", "(", "&", "cfg", ")", "\n", "return", "&", "cfg", ",", "nil", "\n", "}" ]

[ "ReadCfg", "reads", "and", "unmarshals", "the", "specified", "json", "file", "into", "a", "Cfg", "struct", "." ]

[ "func", "(", "v", "*", "Vendorer", ")", "findOpenAPI", "(", "root", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "finfos", ",", "err", ":=", "ioutil", ".", "ReadDir", "(", "root", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "var", "res", "[", "]", "string", "\n", "var", "includeMe", "bool", "\n", "for", "_", ",", "finfo", ":=", "range", "finfos", "{", "path", ":=", "filepath", ".", "Join", "(", "root", ",", "finfo", ".", "Name", "(", ")", ")", "\n", "if", "finfo", ".", "IsDir", "(", ")", "&&", "(", "finfo", ".", "Mode", "(", ")", "&", "os", ".", "ModeSymlink", "==", "0", ")", "{", "children", ",", "err", ":=", "v", ".", "findOpenAPI", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "res", "=", "append", "(", "res", ",", "children", "...", ")", "\n", "}", "else", "if", "strings", ".", "HasSuffix", "(", "path", ",", "\"", "\"", ")", "&&", "!", "strings", ".", "HasSuffix", "(", "path", ",", "\"", "\"", ")", "{", "b", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "bytes", ".", "Contains", "(", "b", ",", "[", "]", "byte", "(", "openAPIGenTag", ")", ")", "{", "includeMe", "=", "true", "\n", "}", "\n", "}", "\n", "}", "\n", "if", "includeMe", "{", "pkg", ",", "err", ":=", "v", ".", "ctx", ".", "ImportDir", "(", "root", ",", "0", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "res", "=", "append", "(", "res", ",", "pkg", ".", "ImportPath", ")", "\n", "}", "\n", "return", "res", ",", "nil", "\n", "}" ]

[ "findOpenAPI", "searches", "for", "all", "packages", "under", "root", "that", "request", "OpenAPI", ".", "It", "returns", "the", "go", "import", "paths", ".", "It", "does", "not", "follow", "symlinks", "." ]

[ "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", ",", "}", "\n", "}" ]

[ "NewRBDProvisioner", "creates", "a", "Provisioner", "that", "provisions", "Ceph", "RBD", "PVs", "backed", "by", "Ceph", "RBD", "images", "." ]

[ "func", "(", "p", "*", "rbdProvisioner", ")", "getAccessModes", "(", ")", "[", "]", "v1", ".", "PersistentVolumeAccessMode", "{", "return", "[", "]", "v1", ".", "PersistentVolumeAccessMode", "{", "v1", ".", "ReadWriteOnce", ",", "v1", ".", "ReadOnlyMany", ",", "}", "\n", "}" ]

[ "getAccessModes", "returns", "access", "modes", "RBD", "volume", "supported", "." ]

[ "func", "(", "p", "*", "rbdProvisioner", ")", "parsePVSecret", "(", "namespace", ",", "secretName", "string", ")", "(", "string", ",", "error", ")", "{", "if", "p", ".", "client", "==", "nil", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "secrets", ",", "err", ":=", "p", ".", "client", ".", "CoreV1", "(", ")", ".", "Secrets", "(", "namespace", ")", ".", "Get", "(", "secretName", ",", "metav1", ".", "GetOptions", "{", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "// TODO: Should we check secret.Type, like `k8s.io/kubernetes/pkg/volume/util.GetSecretForPV` function?", "secret", ":=", "\"", "\"", "\n", "for", "k", ",", "v", ":=", "range", "secrets", ".", "Data", "{", "if", "k", "==", "secretKeyName", "{", "return", "string", "(", "v", ")", ",", "nil", "\n", "}", "\n", "secret", "=", "string", "(", "v", ")", "\n", "}", "\n\n", "// If not found, the last secret in the map wins as done before", "return", "secret", ",", "nil", "\n", "}" ]

[ "parsePVSecret", "retrives", "secret", "value", "for", "a", "given", "namespace", "and", "name", "." ]

[ "func", "(", "in", "*", "AWSElasticBlockStoreVolumeSnapshotSource", ")", "DeepCopy", "(", ")", "*", "AWSElasticBlockStoreVolumeSnapshotSource", "{", "if", "in", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "out", ":=", "new", "(", "AWSElasticBlockStoreVolumeSnapshotSource", ")", "\n", "in", ".", "DeepCopyInto", "(", "out", ")", "\n", "return", "out", "\n", "}" ]

[ "DeepCopy", "is", "an", "autogenerated", "deepcopy", "function", "copying", "the", "receiver", "creating", "a", "new", "AWSElasticBlockStoreVolumeSnapshotSource", "." ]

[ "func", "(", "in", "*", "CinderVolumeSnapshotSource", ")", "DeepCopy", "(", ")", "*", "CinderVolumeSnapshotSource", "{", "if", "in", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "out", ":=", "new", "(", "CinderVolumeSnapshotSource", ")", "\n", "in", ".", "DeepCopyInto", "(", "out", ")", "\n", "return", "out", "\n", "}" ]

[ "DeepCopy", "is", "an", "autogenerated", "deepcopy", "function", "copying", "the", "receiver", "creating", "a", "new", "CinderVolumeSnapshotSource", "." ]

[ "func", "(", "in", "*", "GCEPersistentDiskSnapshotSource", ")", "DeepCopy", "(", ")", "*", "GCEPersistentDiskSnapshotSource", "{", "if", "in", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "out", ":=", "new", "(", "GCEPersistentDiskSnapshotSource", ")", "\n", "in", ".", "DeepCopyInto", "(", "out", ")", "\n", "return", "out", "\n", "}" ]

[ "DeepCopy", "is", "an", "autogenerated", "deepcopy", "function", "copying", "the", "receiver", "creating", "a", "new", "GCEPersistentDiskSnapshotSource", "." ]

[ "func", "(", "in", "*", "GlusterVolumeSnapshotSource", ")", "DeepCopy", "(", ")", "*", "GlusterVolumeSnapshotSource", "{", "if", "in", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "out", ":=", "new", "(", "GlusterVolumeSnapshotSource", ")", "\n", "in", ".", "DeepCopyInto", "(", "out", ")", "\n", "return", "out", "\n", "}" ]

[ "DeepCopy", "is", "an", "autogenerated", "deepcopy", "function", "copying", "the", "receiver", "creating", "a", "new", "GlusterVolumeSnapshotSource", "." ]

[ "func", "(", "in", "*", "HostPathVolumeSnapshotSource", ")", "DeepCopy", "(", ")", "*", "HostPathVolumeSnapshotSource", "{", "if", "in", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "out", ":=", "new", "(", "HostPathVolumeSnapshotSource", ")", "\n", "in", ".", "DeepCopyInto", "(", "out", ")", "\n", "return", "out", "\n", "}" ]

[ "DeepCopy", "is", "an", "autogenerated", "deepcopy", "function", "copying", "the", "receiver", "creating", "a", "new", "HostPathVolumeSnapshotSource", "." ]

[ "func", "(", "in", "*", "VolumeSnapshot", ")", "DeepCopy", "(", ")", "*", "VolumeSnapshot", "{", "if", "in", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "out", ":=", "new", "(", "VolumeSnapshot", ")", "\n", "in", ".", "DeepCopyInto", "(", "out", ")", "\n", "return", "out", "\n", "}" ]

[ "DeepCopy", "is", "an", "autogenerated", "deepcopy", "function", "copying", "the", "receiver", "creating", "a", "new", "VolumeSnapshot", "." ]

[ "func", "(", "in", "*", "VolumeSnapshotCondition", ")", "DeepCopy", "(", ")", "*", "VolumeSnapshotCondition", "{", "if", "in", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "out", ":=", "new", "(", "VolumeSnapshotCondition", ")", "\n", "in", ".", "DeepCopyInto", "(", "out", ")", "\n", "return", "out", "\n", "}" ]

[ "DeepCopy", "is", "an", "autogenerated", "deepcopy", "function", "copying", "the", "receiver", "creating", "a", "new", "VolumeSnapshotCondition", "." ]

[ "func", "(", "in", "*", "VolumeSnapshotCopy", ")", "DeepCopy", "(", ")", "*", "VolumeSnapshotCopy", "{", "if", "in", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "out", ":=", "new", "(", "VolumeSnapshotCopy", ")", "\n", "in", ".", "DeepCopyInto", "(", "out", ")", "\n", "return", "out", "\n", "}" ]

[ "DeepCopy", "is", "an", "autogenerated", "deepcopy", "function", "copying", "the", "receiver", "creating", "a", "new", "VolumeSnapshotCopy", "." ]

[ "func", "(", "in", "*", "VolumeSnapshotData", ")", "DeepCopy", "(", ")", "*", "VolumeSnapshotData", "{", "if", "in", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "out", ":=", "new", "(", "VolumeSnapshotData", ")", "\n", "in", ".", "DeepCopyInto", "(", "out", ")", "\n", "return", "out", "\n", "}" ]

[ "DeepCopy", "is", "an", "autogenerated", "deepcopy", "function", "copying", "the", "receiver", "creating", "a", "new", "VolumeSnapshotData", "." ]

[ "func", "(", "in", "*", "VolumeSnapshotDataCondition", ")", "DeepCopy", "(", ")", "*", "VolumeSnapshotDataCondition", "{", "if", "in", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "out", ":=", "new", "(", "VolumeSnapshotDataCondition", ")", "\n", "in", ".", "DeepCopyInto", "(", "out", ")", "\n", "return", "out", "\n", "}" ]

[ "DeepCopy", "is", "an", "autogenerated", "deepcopy", "function", "copying", "the", "receiver", "creating", "a", "new", "VolumeSnapshotDataCondition", "." ]

[ "func", "(", "in", "*", "VolumeSnapshotDataCopy", ")", "DeepCopy", "(", ")", "*", "VolumeSnapshotDataCopy", "{", "if", "in", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "out", ":=", "new", "(", "VolumeSnapshotDataCopy", ")", "\n", "in", ".", "DeepCopyInto", "(", "out", ")", "\n", "return", "out", "\n", "}" ]

[ "DeepCopy", "is", "an", "autogenerated", "deepcopy", "function", "copying", "the", "receiver", "creating", "a", "new", "VolumeSnapshotDataCopy", "." ]

[ "func", "(", "in", "*", "VolumeSnapshotDataList", ")", "DeepCopy", "(", ")", "*", "VolumeSnapshotDataList", "{", "if", "in", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "out", ":=", "new", "(", "VolumeSnapshotDataList", ")", "\n", "in", ".", "DeepCopyInto", "(", "out", ")", "\n", "return", "out", "\n", "}" ]

[ "DeepCopy", "is", "an", "autogenerated", "deepcopy", "function", "copying", "the", "receiver", "creating", "a", "new", "VolumeSnapshotDataList", "." ]

[ "func", "(", "in", "*", "VolumeSnapshotDataListCopy", ")", "DeepCopy", "(", ")", "*", "VolumeSnapshotDataListCopy", "{", "if", "in", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "out", ":=", "new", "(", "VolumeSnapshotDataListCopy", ")", "\n", "in", ".", "DeepCopyInto", "(", "out", ")", "\n", "return", "out", "\n", "}" ]

[ "DeepCopy", "is", "an", "autogenerated", "deepcopy", "function", "copying", "the", "receiver", "creating", "a", "new", "VolumeSnapshotDataListCopy", "." ]

[ "func", "(", "in", "*", "VolumeSnapshotDataSource", ")", "DeepCopy", "(", ")", "*", "VolumeSnapshotDataSource", "{", "if", "in", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "out", ":=", "new", "(", "VolumeSnapshotDataSource", ")", "\n", "in", ".", "DeepCopyInto", "(", "out", ")", "\n", "return", "out", "\n", "}" ]

[ "DeepCopy", "is", "an", "autogenerated", "deepcopy", "function", "copying", "the", "receiver", "creating", "a", "new", "VolumeSnapshotDataSource", "." ]

[ "func", "(", "in", "*", "VolumeSnapshotDataSpec", ")", "DeepCopy", "(", ")", "*", "VolumeSnapshotDataSpec", "{", "if", "in", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "out", ":=", "new", "(", "VolumeSnapshotDataSpec", ")", "\n", "in", ".", "DeepCopyInto", "(", "out", ")", "\n", "return", "out", "\n", "}" ]

[ "DeepCopy", "is", "an", "autogenerated", "deepcopy", "function", "copying", "the", "receiver", "creating", "a", "new", "VolumeSnapshotDataSpec", "." ]

[ "func", "(", "in", "*", "VolumeSnapshotDataStatus", ")", "DeepCopy", "(", ")", "*", "VolumeSnapshotDataStatus", "{", "if", "in", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "out", ":=", "new", "(", "VolumeSnapshotDataStatus", ")", "\n", "in", ".", "DeepCopyInto", "(", "out", ")", "\n", "return", "out", "\n", "}" ]

[ "DeepCopy", "is", "an", "autogenerated", "deepcopy", "function", "copying", "the", "receiver", "creating", "a", "new", "VolumeSnapshotDataStatus", "." ]

[ "func", "(", "in", "*", "VolumeSnapshotList", ")", "DeepCopy", "(", ")", "*", "VolumeSnapshotList", "{", "if", "in", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "out", ":=", "new", "(", "VolumeSnapshotList", ")", "\n", "in", ".", "DeepCopyInto", "(", "out", ")", "\n", "return", "out", "\n", "}" ]

[ "DeepCopy", "is", "an", "autogenerated", "deepcopy", "function", "copying", "the", "receiver", "creating", "a", "new", "VolumeSnapshotList", "." ]

[ "func", "(", "in", "*", "VolumeSnapshotListCopy", ")", "DeepCopy", "(", ")", "*", "VolumeSnapshotListCopy", "{", "if", "in", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "out", ":=", "new", "(", "VolumeSnapshotListCopy", ")", "\n", "in", ".", "DeepCopyInto", "(", "out", ")", "\n", "return", "out", "\n", "}" ]

[ "DeepCopy", "is", "an", "autogenerated", "deepcopy", "function", "copying", "the", "receiver", "creating", "a", "new", "VolumeSnapshotListCopy", "." ]

[ "func", "(", "in", "*", "VolumeSnapshotSpec", ")", "DeepCopy", "(", ")", "*", "VolumeSnapshotSpec", "{", "if", "in", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "out", ":=", "new", "(", "VolumeSnapshotSpec", ")", "\n", "in", ".", "DeepCopyInto", "(", "out", ")", "\n", "return", "out", "\n", "}" ]

[ "DeepCopy", "is", "an", "autogenerated", "deepcopy", "function", "copying", "the", "receiver", "creating", "a", "new", "VolumeSnapshotSpec", "." ]

[ "func", "(", "in", "*", "VolumeSnapshotStatus", ")", "DeepCopy", "(", ")", "*", "VolumeSnapshotStatus", "{", "if", "in", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "out", ":=", "new", "(", "VolumeSnapshotStatus", ")", "\n", "in", ".", "DeepCopyInto", "(", "out", ")", "\n", "return", "out", "\n", "}" ]

[ "DeepCopy", "is", "an", "autogenerated", "deepcopy", "function", "copying", "the", "receiver", "creating", "a", "new", "VolumeSnapshotStatus", "." ]

[ "func", "(", "lbaas", "*", "LbaasV2", ")", "GetLoadBalancer", "(", "clusterName", "string", ",", "service", "*", "v1", ".", "Service", ")", "(", "*", "v1", ".", "LoadBalancerStatus", ",", "bool", ",", "error", ")", "{", "loadBalancerName", ":=", "cloudprovider", ".", "GetLoadBalancerName", "(", "service", ")", "\n", "loadbalancer", ",", "err", ":=", "getLoadbalancerByName", "(", "lbaas", ".", "network", ",", "loadBalancerName", ")", "\n", "if", "err", "==", "ErrNotFound", "{", "return", "nil", ",", "false", ",", "nil", "\n", "}", "\n", "if", "loadbalancer", "==", "nil", "{", "return", "nil", ",", "false", ",", "err", "\n", "}", "\n\n", "status", ":=", "&", "v1", ".", "LoadBalancerStatus", "{", "}", "\n", "status", ".", "Ingress", "=", "[", "]", "v1", ".", "LoadBalancerIngress", "{", "{", "IP", ":", "loadbalancer", ".", "VipAddress", "}", "}", "\n\n", "return", "status", ",", "true", ",", "err", "\n", "}" ]

[ "GetLoadBalancer", "gets", "the", "status", "of", "the", "load", "balancer" ]

[ "func", "(", "lb", "*", "LbaasV1", ")", "GetLoadBalancer", "(", "clusterName", "string", ",", "service", "*", "v1", ".", "Service", ")", "(", "*", "v1", ".", "LoadBalancerStatus", ",", "bool", ",", "error", ")", "{", "loadBalancerName", ":=", "cloudprovider", ".", "GetLoadBalancerName", "(", "service", ")", "\n", "vip", ",", "err", ":=", "getVipByName", "(", "lb", ".", "network", ",", "loadBalancerName", ")", "\n", "if", "err", "==", "ErrNotFound", "{", "return", "nil", ",", "false", ",", "nil", "\n", "}", "\n", "if", "vip", "==", "nil", "{", "return", "nil", ",", "false", ",", "err", "\n", "}", "\n\n", "status", ":=", "&", "v1", ".", "LoadBalancerStatus", "{", "}", "\n", "status", ".", "Ingress", "=", "[", "]", "v1", ".", "LoadBalancerIngress", "{", "{", "IP", ":", "vip", ".", "Address", "}", "}", "\n\n", "return", "status", ",", "true", ",", "err", "\n", "}" ]

[ "GetLoadBalancer", "gets", "a", "load", "balancer" ]

[ "func", "(", "v", "OpenEBSVolume", ")", "GetMayaClusterIP", "(", "client", "kubernetes", ".", "Interface", ")", "(", "string", ",", "error", ")", "{", "clusterIP", ":=", "\"", "\"", "\n\n", "namespace", ":=", "os", ".", "Getenv", "(", "\"", "\"", ")", "\n", "if", "namespace", "==", "\"", "\"", "{", "namespace", "=", "\"", "\"", "\n", "}", "\n\n", "glog", ".", "Info", "(", "\"", "\"", ",", "namespace", ")", "\n", "//Fetch the Maya ClusterIP using the Maya API Server Service", "sc", ",", "err", ":=", "client", ".", "CoreV1", "(", ")", ".", "Services", "(", "namespace", ")", ".", "Get", "(", "\"", "\"", ",", "metav1", ".", "GetOptions", "{", "}", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "clusterIP", "=", "sc", ".", "Spec", ".", "ClusterIP", "\n", "glog", ".", "V", "(", "2", ")", ".", "Infof", "(", "\"", "\"", ",", "clusterIP", ")", "\n\n", "return", "clusterIP", ",", "err", "\n", "}" ]

[ "GetMayaClusterIP", "returns", "maya", "-", "apiserver", "IP", "address" ]

[ "func", "(", "v", "OpenEBSVolume", ")", "CreateVolume", "(", "vs", "mayav1", ".", "VolumeSpec", ")", "(", "string", ",", "error", ")", "{", "addr", ":=", "os", ".", "Getenv", "(", "\"", "\"", ")", "\n", "if", "addr", "==", "\"", "\"", "{", "err", ":=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "glog", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "url", ":=", "addr", "+", "\"", "\"", "\n\n", "vs", ".", "Kind", "=", "\"", "\"", "\n", "vs", ".", "APIVersion", "=", "\"", "\"", "\n\n", "//Marshal serializes the value provided into a YAML document", "yamlValue", ",", "_", ":=", "yaml", ".", "Marshal", "(", "vs", ")", "\n\n", "glog", ".", "V", "(", "2", ")", ".", "Infof", "(", "\"", "\\n", "\\n", "\"", ",", "string", "(", "yamlValue", ")", ")", "\n\n", "req", ",", "err", ":=", "http", ".", "NewRequest", "(", "\"", "\"", ",", "url", ",", "bytes", ".", "NewBuffer", "(", "yamlValue", ")", ")", "\n\n", "req", ".", "Header", ".", "Add", "(", "\"", "\"", ",", "\"", "\"", ")", "\n\n", "c", ":=", "&", "http", ".", "Client", "{", "Timeout", ":", "timeout", ",", "}", "\n", "resp", ",", "err", ":=", "c", ".", "Do", "(", "req", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "defer", "resp", ".", "Body", ".", "Close", "(", ")", "\n\n", "data", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "resp", ".", "Body", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "code", ":=", "resp", ".", "StatusCode", "\n", "if", "code", "!=", "http", ".", "StatusOK", "{", "glog", ".", "Errorf", "(", "\"", "\\n", "\"", ",", "http", ".", "StatusText", "(", "code", ")", ")", "\n", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "glog", ".", "Infof", "(", "\"", "\\n", "\\n", "\"", ",", "string", "(", "data", ")", ")", "\n", "return", "\"", "\"", ",", "nil", "\n", "}" ]

[ "CreateVolume", "to", "create", "the", "Vsm", "through", "a", "API", "call", "to", "m", "-", "apiserver" ]

[ "func", "(", "v", "OpenEBSVolume", ")", "ListVolume", "(", "vname", "string", ",", "obj", "interface", "{", "}", ")", "error", "{", "addr", ":=", "os", ".", "Getenv", "(", "\"", "\"", ")", "\n", "if", "addr", "==", "\"", "\"", "{", "err", ":=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "glog", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "url", ":=", "addr", "+", "\"", "\"", "+", "vname", "\n\n", "glog", ".", "V", "(", "2", ")", ".", "Infof", "(", "\"", "\"", ",", "string", "(", "vname", ")", ")", "\n\n", "req", ",", "err", ":=", "http", ".", "NewRequest", "(", "\"", "\"", ",", "url", ",", "nil", ")", "\n", "c", ":=", "&", "http", ".", "Client", "{", "Timeout", ":", "timeout", ",", "}", "\n", "resp", ",", "err", ":=", "c", ".", "Do", "(", "req", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "defer", "resp", ".", "Body", ".", "Close", "(", ")", "\n\n", "code", ":=", "resp", ".", "StatusCode", "\n", "if", "code", "!=", "http", ".", "StatusOK", "{", "glog", ".", "Errorf", "(", "\"", "\\n", "\"", ",", "http", ".", "StatusText", "(", "code", ")", ")", "\n", "return", "err", "\n", "}", "\n", "glog", ".", "V", "(", "2", ")", ".", "Info", "(", "\"", "\"", ")", "\n", "return", "json", ".", "NewDecoder", "(", "resp", ".", "Body", ")", ".", "Decode", "(", "obj", ")", "\n", "}" ]

[ "ListVolume", "to", "get", "the", "info", "of", "Vsm", "through", "a", "API", "call", "to", "m", "-", "apiserver" ]

[ "func", "NewEFSProvisioner", "(", "client", "kubernetes", ".", "Interface", ")", "controller", ".", "Provisioner", "{", "fileSystemID", ":=", "os", ".", "Getenv", "(", "fileSystemIDKey", ")", "\n", "if", "fileSystemID", "==", "\"", "\"", "{", "klog", ".", "Fatalf", "(", "\"", "\"", ",", "fileSystemIDKey", ")", "\n", "}", "\n\n", "awsRegion", ":=", "os", ".", "Getenv", "(", "awsRegionKey", ")", "\n", "if", "awsRegion", "==", "\"", "\"", "{", "klog", ".", "Fatalf", "(", "\"", "\"", ",", "awsRegionKey", ")", "\n", "}", "\n\n", "dnsName", ":=", "os", ".", "Getenv", "(", "dnsNameKey", ")", "\n", "klog", ".", "Errorf", "(", "\"", "\"", ",", "dnsName", ")", "\n", "if", "dnsName", "==", "\"", "\"", "{", "dnsName", "=", "getDNSName", "(", "fileSystemID", ",", "awsRegion", ")", "\n", "}", "\n\n", "mountpoint", ",", "source", ",", "err", ":=", "getMount", "(", "dnsName", ")", "\n", "if", "err", "!=", "nil", "{", "klog", ".", "Fatal", "(", "err", ")", "\n", "}", "\n\n", "sess", ",", "err", ":=", "session", ".", "NewSession", "(", ")", "\n", "if", "err", "!=", "nil", "{", "klog", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "svc", ":=", "efs", ".", "New", "(", "sess", ",", "&", "aws", ".", "Config", "{", "Region", ":", "aws", ".", "String", "(", "awsRegion", ")", "}", ")", "\n", "params", ":=", "&", "efs", ".", "DescribeFileSystemsInput", "{", "FileSystemId", ":", "aws", ".", "String", "(", "fileSystemID", ")", ",", "}", "\n\n", "_", ",", "err", "=", "svc", ".", "DescribeFileSystems", "(", "params", ")", "\n", "if", "err", "!=", "nil", "{", "klog", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "&", "efsProvisioner", "{", "dnsName", ":", "dnsName", ",", "mountpoint", ":", "mountpoint", ",", "source", ":", "source", ",", "allocator", ":", "gidallocator", ".", "New", "(", "client", ")", ",", "}", "\n", "}" ]

[ "NewEFSProvisioner", "creates", "an", "AWS", "EFS", "volume", "provisioner" ]

[ "func", "(", "u", "*", "apiUtil", ")", "CreatePV", "(", "pv", "*", "v1", ".", "PersistentVolume", ")", "(", "*", "v1", ".", "PersistentVolume", ",", "error", ")", "{", "startTime", ":=", "time", ".", "Now", "(", ")", "\n", "metrics", ".", "APIServerRequestsTotal", ".", "WithLabelValues", "(", "metrics", ".", "APIServerRequestCreate", ")", ".", "Inc", "(", ")", "\n", "pv", ",", "err", ":=", "u", ".", "client", ".", "CoreV1", "(", ")", ".", "PersistentVolumes", "(", ")", ".", "Create", "(", "pv", ")", "\n", "metrics", ".", "APIServerRequestsDurationSeconds", ".", "WithLabelValues", "(", "metrics", ".", "APIServerRequestCreate", ")", ".", "Observe", "(", "time", ".", "Since", "(", "startTime", ")", ".", "Seconds", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "metrics", ".", "APIServerRequestsFailedTotal", ".", "WithLabelValues", "(", "metrics", ".", "APIServerRequestCreate", ")", ".", "Inc", "(", ")", "\n", "}", "\n", "return", "pv", ",", "err", "\n", "}" ]

[ "CreatePV", "will", "create", "a", "PersistentVolume" ]

[ "func", "(", "u", "*", "apiUtil", ")", "DeletePV", "(", "pvName", "string", ")", "error", "{", "startTime", ":=", "time", ".", "Now", "(", ")", "\n", "metrics", ".", "APIServerRequestsTotal", ".", "WithLabelValues", "(", "metrics", ".", "APIServerRequestDelete", ")", ".", "Inc", "(", ")", "\n", "err", ":=", "u", ".", "client", ".", "CoreV1", "(", ")", ".", "PersistentVolumes", "(", ")", ".", "Delete", "(", "pvName", ",", "&", "metav1", ".", "DeleteOptions", "{", "}", ")", "\n", "metrics", ".", "APIServerRequestsDurationSeconds", ".", "WithLabelValues", "(", "metrics", ".", "APIServerRequestDelete", ")", ".", "Observe", "(", "time", ".", "Since", "(", "startTime", ")", ".", "Seconds", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "metrics", ".", "APIServerRequestsFailedTotal", ".", "WithLabelValues", "(", "metrics", ".", "APIServerRequestDelete", ")", ".", "Inc", "(", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "DeletePV", "will", "delete", "a", "PersistentVolume" ]

[ "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", ":", "cache", ",", "}", "\n", "}" ]

[ "NewFakeAPIUtil", "returns", "an", "APIUtil", "object", "that", "can", "be", "used", "for", "unit", "testing" ]