Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "u", "*", "FakeAPIUtil", ")", "CreatePV", "(", "pv", "*", "v1", ".", "PersistentVolume", ")", "(", "*", "v1", ".", "PersistentVolume", ",", "error", ")", "{", "if", "u", ".", "shouldFail", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "u", ".", "createdPVs", "[", "pv", ".", "Name", "]", "=", "pv", "\n", "u", ".", "cache", ".", "AddPV", "(", "pv", ")", "\n", "return", "pv", ",", "nil", "\n", "}" ]

[ "CreatePV", "will", "add", "the", "PV", "to", "the", "created", "list", "and", "cache" ]

[ "func", "(", "u", "*", "FakeAPIUtil", ")", "DeletePV", "(", "pvName", "string", ")", "error", "{", "if", "u", ".", "shouldFail", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "pv", ",", "exists", ":=", "u", ".", "cache", ".", "GetPV", "(", "pvName", ")", "\n", "if", "exists", "{", "u", ".", "deletedPVs", "[", "pvName", "]", "=", "pv", "\n", "delete", "(", "u", ".", "createdPVs", ",", "pvName", ")", "\n", "u", ".", "cache", ".", "DeletePV", "(", "pvName", ")", "\n", "return", "nil", "\n", "}", "\n", "return", "errors", ".", "NewNotFound", "(", "v1", ".", "Resource", "(", "\"", "\"", ")", ",", "pvName", ")", "\n", "}" ]

[ "DeletePV", "will", "delete", "the", "PV", "from", "the", "created", "list", "and", "cache", "and", "also", "add", "it", "to", "the", "deleted", "list" ]

[ "func", "(", "u", "*", "FakeAPIUtil", ")", "GetAndResetCreatedPVs", "(", ")", "map", "[", "string", "]", "*", "v1", ".", "PersistentVolume", "{", "createdPVs", ":=", "u", ".", "createdPVs", "\n", "u", ".", "createdPVs", "=", "map", "[", "string", "]", "*", "v1", ".", "PersistentVolume", "{", "}", "\n", "return", "createdPVs", "\n", "}" ]

[ "GetAndResetCreatedPVs", "returns", "createdPVs", "and", "resets", "the", "map", "This", "is", "only", "for", "testing" ]

[ "func", "(", "u", "*", "FakeAPIUtil", ")", "GetAndResetDeletedPVs", "(", ")", "map", "[", "string", "]", "*", "v1", ".", "PersistentVolume", "{", "deletedPVs", ":=", "u", ".", "deletedPVs", "\n", "u", ".", "deletedPVs", "=", "map", "[", "string", "]", "*", "v1", ".", "PersistentVolume", "{", "}", "\n", "return", "deletedPVs", "\n", "}" ]

[ "GetAndResetDeletedPVs", "returns", "createdPVs", "and", "resets", "the", "map", "This", "is", "only", "for", "testing" ]

[ "func", "(", "u", "*", "FakeAPIUtil", ")", "CreateJob", "(", "job", "*", "batch_v1", ".", "Job", ")", "error", "{", "u", ".", "CreatedJobs", "[", "job", ".", "Namespace", "+", "\"", "\"", "+", "job", ".", "Name", "]", "=", "job", "\n", "return", "nil", "\n", "}" ]

[ "CreateJob", "mocks", "job", "create", "method", "." ]

[ "func", "(", "u", "*", "FakeAPIUtil", ")", "DeleteJob", "(", "jobName", "string", ",", "namespace", "string", ")", "error", "{", "u", ".", "DeletedJobs", "[", "namespace", "+", "\"", "\"", "+", "jobName", "]", "=", "jobName", "\n", "return", "nil", "\n", "}" ]

[ "DeleteJob", "mocks", "delete", "jon", "method", "." ]

[ "func", "(", "c", "*", "Cloud", ")", "getInstancesByRegex", "(", "regex", "string", ")", "(", "[", "]", "types", ".", "NodeName", ",", "error", ")", "{", "filters", ":=", "[", "]", "*", "ec2", ".", "Filter", "{", "newEc2Filter", "(", "\"", "\"", ",", "\"", "\"", ")", "}", "\n\n", "instances", ",", "err", ":=", "c", ".", "describeInstances", "(", "filters", ")", "\n", "if", "err", "!=", "nil", "{", "return", "[", "]", "types", ".", "NodeName", "{", "}", ",", "err", "\n", "}", "\n\n", "if", "len", "(", "instances", ")", "==", "0", "{", "return", "[", "]", "types", ".", "NodeName", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "strings", ".", "HasPrefix", "(", "regex", ",", "\"", "\"", ")", "&&", "strings", ".", "HasSuffix", "(", "regex", ",", "\"", "\"", ")", "{", "glog", ".", "Infof", "(", "\"", "\"", ",", "regex", ")", "\n", "regex", "=", "regex", "[", "1", ":", "len", "(", "regex", ")", "-", "1", "]", "\n", "}", "\n\n", "re", ",", "err", ":=", "regexp", ".", "Compile", "(", "regex", ")", "\n", "if", "err", "!=", "nil", "{", "return", "[", "]", "types", ".", "NodeName", "{", "}", ",", "err", "\n", "}", "\n\n", "matchingInstances", ":=", "[", "]", "types", ".", "NodeName", "{", "}", "\n", "for", "_", ",", "instance", ":=", "range", "instances", "{", "// Only return fully-ready instances when listing instances", "// (vs a query by name, where we will return it if we find it)", "if", "orEmpty", "(", "instance", ".", "State", ".", "Name", ")", "==", "\"", "\"", "{", "glog", ".", "V", "(", "2", ")", ".", "Infof", "(", "\"", "\"", ",", "*", "instance", ".", "InstanceId", ")", "\n", "continue", "\n", "}", "\n\n", "nodeName", ":=", "mapInstanceToNodeName", "(", "instance", ")", "\n", "if", "nodeName", "==", "\"", "\"", "{", "glog", ".", "V", "(", "2", ")", ".", "Infof", "(", "\"", "\"", ",", "aws", ".", "StringValue", "(", "instance", ".", "InstanceId", ")", ")", "\n", "continue", "\n", "}", "\n\n", "for", "_", ",", "tag", ":=", "range", "instance", ".", "Tags", "{", "if", "orEmpty", "(", "tag", ".", "Key", ")", "==", "\"", "\"", "&&", "re", ".", "MatchString", "(", "orEmpty", "(", "tag", ".", "Value", ")", ")", "{", "matchingInstances", "=", "append", "(", "matchingInstances", ",", "nodeName", ")", "\n", "break", "\n", "}", "\n", "}", "\n", "}", "\n", "glog", ".", "V", "(", "2", ")", ".", "Infof", "(", "\"", "\"", ",", "matchingInstances", ")", "\n", "return", "matchingInstances", ",", "nil", "\n", "}" ]

[ "Return", "a", "list", "of", "instances", "matching", "regex", "string", "." ]

[ "func", "(", "c", "*", "Cloud", ")", "getMountDevice", "(", "i", "*", "awsInstance", ",", "info", "*", "ec2", ".", "Instance", ",", "volumeID", "awsVolumeID", ",", "assign", "bool", ")", "(", "assigned", "mountDevice", ",", "alreadyAttached", "bool", ",", "err", "error", ")", "{", "instanceType", ":=", "i", ".", "getInstanceType", "(", ")", "\n", "if", "instanceType", "==", "nil", "{", "return", "\"", "\"", ",", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "i", ".", "awsID", ")", "\n", "}", "\n\n", "deviceMappings", ":=", "map", "[", "mountDevice", "]", "awsVolumeID", "{", "}", "\n", "for", "_", ",", "blockDevice", ":=", "range", "info", ".", "BlockDeviceMappings", "{", "name", ":=", "aws", ".", "StringValue", "(", "blockDevice", ".", "DeviceName", ")", "\n", "if", "strings", ".", "HasPrefix", "(", "name", ",", "\"", "\"", ")", "{", "name", "=", "name", "[", "7", ":", "]", "\n", "}", "\n", "if", "strings", ".", "HasPrefix", "(", "name", ",", "\"", "\"", ")", "{", "name", "=", "name", "[", "8", ":", "]", "\n", "}", "\n", "if", "len", "(", "name", ")", "<", "1", "||", "len", "(", "name", ")", ">", "2", "{", "glog", ".", "Warningf", "(", "\"", "\"", ",", "aws", ".", "StringValue", "(", "blockDevice", ".", "DeviceName", ")", ")", "\n", "}", "\n", "deviceMappings", "[", "mountDevice", "(", "name", ")", "]", "=", "awsVolumeID", "(", "aws", ".", "StringValue", "(", "blockDevice", ".", "Ebs", ".", "VolumeId", ")", ")", "\n", "}", "\n\n", "// We lock to prevent concurrent mounts from conflicting", "// We may still conflict if someone calls the API concurrently,", "// but the AWS API will then fail one of the two attach operations", "c", ".", "attachingMutex", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "attachingMutex", ".", "Unlock", "(", ")", "\n\n", "for", "mountDevice", ",", "volume", ":=", "range", "c", ".", "attaching", "[", "i", ".", "nodeName", "]", "{", "deviceMappings", "[", "mountDevice", "]", "=", "volume", "\n", "}", "\n\n", "// Check to see if this volume is already assigned a device on this machine", "for", "mountDevice", ",", "mappingVolumeID", ":=", "range", "deviceMappings", "{", "if", "volumeID", "==", "mappingVolumeID", "{", "if", "assign", "{", "glog", ".", "Warningf", "(", "\"", "\"", ",", "mountDevice", ",", "mappingVolumeID", ")", "\n", "}", "\n", "return", "mountDevice", ",", "true", ",", "nil", "\n", "}", "\n", "}", "\n\n", "if", "!", "assign", "{", "return", "mountDevice", "(", "\"", "\"", ")", ",", "false", ",", "nil", "\n", "}", "\n\n", "// Find the next unused device name", "deviceAllocator", ":=", "c", ".", "deviceAllocators", "[", "i", ".", "nodeName", "]", "\n", "if", "deviceAllocator", "==", "nil", "{", "// we want device names with two significant characters, starting with /dev/xvdbb", "// the allowed range is /dev/xvd[b-c][a-z]", "// http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/device_naming.html", "deviceAllocator", "=", "NewDeviceAllocator", "(", "0", ")", "\n", "c", ".", "deviceAllocators", "[", "i", ".", "nodeName", "]", "=", "deviceAllocator", "\n", "}", "\n", "chosen", ",", "err", ":=", "deviceAllocator", ".", "GetNext", "(", "deviceMappings", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Warningf", "(", "\"", "\"", ",", "deviceMappings", ",", "err", ")", "\n", "return", "\"", "\"", ",", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "i", ".", "nodeName", ")", "\n", "}", "\n\n", "attaching", ":=", "c", ".", "attaching", "[", "i", ".", "nodeName", "]", "\n", "if", "attaching", "==", "nil", "{", "attaching", "=", "make", "(", "map", "[", "mountDevice", "]", "awsVolumeID", ")", "\n", "c", ".", "attaching", "[", "i", ".", "nodeName", "]", "=", "attaching", "\n", "}", "\n", "attaching", "[", "chosen", "]", "=", "volumeID", "\n", "glog", ".", "V", "(", "2", ")", ".", "Infof", "(", "\"", "\"", ",", "chosen", ",", "volumeID", ")", "\n\n", "return", "chosen", ",", "false", ",", "nil", "\n", "}" ]

[ "Gets", "the", "mountDevice", "already", "assigned", "to", "the", "volume", "or", "assigns", "an", "unused", "mountDevice", ".", "If", "the", "volume", "is", "already", "assigned", "this", "will", "return", "the", "existing", "mountDevice", "with", "alreadyAttached", "=", "true", ".", "Otherwise", "the", "mountDevice", "is", "assigned", "by", "finding", "the", "first", "available", "mountDevice", "and", "it", "is", "returned", "with", "alreadyAttached", "=", "false", "." ]

[ "func", "(", "d", "*", "awsDisk", ")", "describeVolume", "(", ")", "(", "*", "ec2", ".", "Volume", ",", "error", ")", "{", "volumeID", ":=", "d", ".", "awsID", "\n\n", "request", ":=", "&", "ec2", ".", "DescribeVolumesInput", "{", "VolumeIds", ":", "[", "]", "*", "string", "{", "volumeID", ".", "awsString", "(", ")", "}", ",", "}", "\n\n", "volumes", ",", "err", ":=", "d", ".", "ec2", ".", "DescribeVolumes", "(", "request", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "volumeID", ",", "err", ")", "\n", "}", "\n", "if", "len", "(", "volumes", ")", "==", "0", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "volumeID", ")", "\n", "}", "\n", "if", "len", "(", "volumes", ")", ">", "1", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "volumeID", ")", "\n", "}", "\n", "return", "volumes", "[", "0", "]", ",", "nil", "\n", "}" ]

[ "Gets", "the", "full", "information", "about", "this", "volume", "from", "the", "EC2", "API" ]

[ "func", "(", "d", "*", "awsDisk", ")", "waitForAttachmentStatus", "(", "status", "string", ")", "(", "*", "ec2", ".", "VolumeAttachment", ",", "error", ")", "{", "backoff", ":=", "wait", ".", "Backoff", "{", "Duration", ":", "volumeAttachmentStatusInitialDelay", ",", "Factor", ":", "volumeAttachmentStatusFactor", ",", "Steps", ":", "volumeAttachmentStatusSteps", ",", "}", "\n\n", "// Because of rate limiting, we often see errors from describeVolume", "// So we tolerate a limited number of failures.", "// But once we see more than 10 errors in a row, we return the error", "describeErrorCount", ":=", "0", "\n", "var", "attachment", "*", "ec2", ".", "VolumeAttachment", "\n\n", "err", ":=", "wait", ".", "ExponentialBackoff", "(", "backoff", ",", "func", "(", ")", "(", "bool", ",", "error", ")", "{", "info", ",", "err", ":=", "d", ".", "describeVolume", "(", ")", "\n", "if", "err", "!=", "nil", "{", "describeErrorCount", "++", "\n", "if", "describeErrorCount", ">", "volumeAttachmentStatusConsecutiveErrorLimit", "{", "// report the error", "return", "false", ",", "err", "\n", "}", "\n", "glog", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "false", ",", "nil", "\n", "}", "\n", "describeErrorCount", "=", "0", "\n", "if", "len", "(", "info", ".", "Attachments", ")", ">", "1", "{", "// Shouldn't happen; log so we know if it is", "glog", ".", "Warningf", "(", "\"", "\"", ",", "d", ".", "awsID", ",", "info", ")", "\n", "}", "\n", "attachmentStatus", ":=", "\"", "\"", "\n", "for", "_", ",", "a", ":=", "range", "info", ".", "Attachments", "{", "if", "attachmentStatus", "!=", "\"", "\"", "{", "// Shouldn't happen; log so we know if it is", "glog", ".", "Warningf", "(", "\"", "\"", ",", "d", ".", "awsID", ",", "info", ")", "\n", "}", "\n", "if", "a", ".", "State", "!=", "nil", "{", "attachment", "=", "a", "\n", "attachmentStatus", "=", "*", "a", ".", "State", "\n", "}", "else", "{", "// Shouldn't happen; log so we know if it is", "glog", ".", "Warningf", "(", "\"", "\"", ",", "d", ".", "awsID", ",", "a", ")", "\n", "}", "\n", "}", "\n", "if", "attachmentStatus", "==", "\"", "\"", "{", "attachmentStatus", "=", "\"", "\"", "\n", "}", "\n", "if", "attachmentStatus", "==", "status", "{", "// Attachment is in requested state, finish waiting", "return", "true", ",", "nil", "\n", "}", "\n", "// continue waiting", "glog", ".", "V", "(", "2", ")", ".", "Infof", "(", "\"", "\"", ",", "d", ".", "awsID", ",", "attachmentStatus", ",", "status", ")", "\n", "return", "false", ",", "nil", "\n", "}", ")", "\n\n", "return", "attachment", ",", "err", "\n", "}" ]

[ "waitForAttachmentStatus", "polls", "until", "the", "attachment", "status", "is", "the", "expected", "value", "On", "success", "it", "returns", "the", "last", "attachment", "state", "." ]

[ "func", "(", "d", "*", "awsDisk", ")", "deleteVolume", "(", ")", "(", "bool", ",", "error", ")", "{", "request", ":=", "&", "ec2", ".", "DeleteVolumeInput", "{", "VolumeId", ":", "d", ".", "awsID", ".", "awsString", "(", ")", "}", "\n", "_", ",", "err", ":=", "d", ".", "ec2", ".", "DeleteVolume", "(", "request", ")", "\n", "if", "err", "!=", "nil", "{", "if", "awsError", ",", "ok", ":=", "err", ".", "(", "awserr", ".", "Error", ")", ";", "ok", "{", "if", "awsError", ".", "Code", "(", ")", "==", "\"", "\"", "{", "return", "false", ",", "nil", "\n", "}", "\n", "if", "awsError", ".", "Code", "(", ")", "==", "\"", "\"", "{", "return", "false", ",", "volume", ".", "NewDeletedVolumeInUseError", "(", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "}", "\n", "return", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "d", ".", "awsID", ",", "err", ")", "\n", "}", "\n", "return", "true", ",", "nil", "\n", "}" ]

[ "Deletes", "the", "EBS", "disk" ]

[ "func", "(", "c", "*", "Cloud", ")", "getAwsInstance", "(", "nodeName", "types", ".", "NodeName", ")", "(", "*", "awsInstance", ",", "error", ")", "{", "var", "awsInstance", "*", "awsInstance", "\n", "if", "nodeName", "==", "\"", "\"", "{", "awsInstance", "=", "c", ".", "selfAWSInstance", "\n", "}", "else", "{", "instance", ",", "err", ":=", "c", ".", "getInstanceByNodeName", "(", "nodeName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "awsInstance", "=", "newAWSInstance", "(", "c", ".", "ec2", ",", "instance", ")", "\n", "}", "\n\n", "return", "awsInstance", ",", "nil", "\n", "}" ]

[ "Gets", "the", "awsInstance", "with", "for", "the", "node", "with", "the", "specified", "nodeName", "or", "the", "self", "instance", "if", "nodeName", "==" ]

[ "func", "(", "c", "*", "Cloud", ")", "GetVolumeLabels", "(", "volumeName", "KubernetesVolumeID", ")", "(", "map", "[", "string", "]", "string", ",", "error", ")", "{", "awsDisk", ",", "err", ":=", "newAWSDisk", "(", "c", ",", "volumeName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "info", ",", "err", ":=", "awsDisk", ".", "describeVolume", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "labels", ":=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "az", ":=", "aws", ".", "StringValue", "(", "info", ".", "AvailabilityZone", ")", "\n", "if", "az", "==", "\"", "\"", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "*", "info", ".", "VolumeId", ")", "\n", "}", "\n\n", "labels", "[", "apis", ".", "LabelZoneFailureDomain", "]", "=", "az", "\n", "region", ",", "err", ":=", "azToRegion", "(", "az", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "labels", "[", "apis", ".", "LabelZoneRegion", "]", "=", "region", "\n\n", "return", "labels", ",", "nil", "\n", "}" ]

[ "GetVolumeLabels", "implements", "Volumes", ".", "GetVolumeLabels" ]

[ "func", "(", "c", "*", "Cloud", ")", "DisksAreAttached", "(", "nodeDisks", "map", "[", "types", ".", "NodeName", "]", "[", "]", "KubernetesVolumeID", ")", "(", "map", "[", "types", ".", "NodeName", "]", "map", "[", "KubernetesVolumeID", "]", "bool", ",", "error", ")", "{", "attached", ":=", "make", "(", "map", "[", "types", ".", "NodeName", "]", "map", "[", "KubernetesVolumeID", "]", "bool", ")", "\n\n", "if", "len", "(", "nodeDisks", ")", "==", "0", "{", "return", "attached", ",", "nil", "\n", "}", "\n\n", "dnsNameSlice", ":=", "[", "]", "string", "{", "}", "\n", "for", "nodeName", ",", "diskNames", ":=", "range", "nodeDisks", "{", "for", "_", ",", "diskName", ":=", "range", "diskNames", "{", "setNodeDisk", "(", "attached", ",", "diskName", ",", "nodeName", ",", "false", ")", "\n", "}", "\n", "dnsNameSlice", "=", "append", "(", "dnsNameSlice", ",", "mapNodeNameToPrivateDNSName", "(", "nodeName", ")", ")", "\n", "}", "\n\n", "awsInstances", ",", "err", ":=", "c", ".", "getInstancesByNodeNames", "(", "dnsNameSlice", ")", "\n", "if", "err", "!=", "nil", "{", "// When there is an error fetching instance information", "// it is safer to return nil and let volume information not be touched.", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "len", "(", "awsInstances", ")", "==", "0", "{", "glog", ".", "V", "(", "2", ")", ".", "Infof", "(", "\"", "\"", ")", "\n", "return", "attached", ",", "nil", "\n", "}", "\n\n", "awsInstanceMap", ":=", "make", "(", "map", "[", "types", ".", "NodeName", "]", "*", "ec2", ".", "Instance", ")", "\n", "for", "_", ",", "awsInstance", ":=", "range", "awsInstances", "{", "awsInstanceMap", "[", "mapInstanceToNodeName", "(", "awsInstance", ")", "]", "=", "awsInstance", "\n", "}", "\n\n", "// Note that we check that the volume is attached to the correct node, not that it is attached to _a_ node", "for", "nodeName", ",", "diskNames", ":=", "range", "nodeDisks", "{", "awsInstance", ":=", "awsInstanceMap", "[", "nodeName", "]", "\n", "if", "awsInstance", "==", "nil", "{", "// If instance no longer exists, safe to assume volume is not attached.", "glog", ".", "Warningf", "(", "\"", "\"", ",", "nodeName", ",", "diskNames", ")", "\n", "continue", "\n", "}", "\n\n", "idToDiskName", ":=", "make", "(", "map", "[", "awsVolumeID", "]", "KubernetesVolumeID", ")", "\n", "for", "_", ",", "diskName", ":=", "range", "diskNames", "{", "volumeID", ",", "err", ":=", "diskName", ".", "mapToAWSVolumeID", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "diskName", ",", "err", ")", "\n", "}", "\n", "idToDiskName", "[", "volumeID", "]", "=", "diskName", "\n", "}", "\n\n", "for", "_", ",", "blockDevice", ":=", "range", "awsInstance", ".", "BlockDeviceMappings", "{", "volumeID", ":=", "awsVolumeID", "(", "aws", ".", "StringValue", "(", "blockDevice", ".", "Ebs", ".", "VolumeId", ")", ")", "\n", "diskName", ",", "found", ":=", "idToDiskName", "[", "volumeID", "]", "\n", "if", "found", "{", "// Disk is still attached to node", "setNodeDisk", "(", "attached", ",", "diskName", ",", "nodeName", ",", "true", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "attached", ",", "nil", "\n", "}" ]

[ "DisksAreAttached", "checks", "whether", "disks", "are", "attached" ]

[ "func", "(", "c", "*", "Cloud", ")", "CreateSnapshot", "(", "snapshotOptions", "*", "SnapshotOptions", ")", "(", "snapshotID", "string", ",", "status", "string", ",", "err", "error", ")", "{", "request", ":=", "&", "ec2", ".", "CreateSnapshotInput", "{", "}", "\n", "request", ".", "VolumeId", "=", "aws", ".", "String", "(", "snapshotOptions", ".", "VolumeID", ")", "\n", "request", ".", "DryRun", "=", "aws", ".", "Bool", "(", "false", ")", "\n", "descriptions", ":=", "\"", "\"", "+", "snapshotOptions", ".", "VolumeID", "\n", "request", ".", "Description", "=", "aws", ".", "String", "(", "descriptions", ")", "\n", "res", ",", "err", ":=", "c", ".", "ec2", ".", "CreateSnapshot", "(", "request", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "err", "\n", "}", "\n", "if", "res", "==", "nil", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "snapshotOptions", ".", "Tags", "!=", "nil", "{", "awsID", ":=", "awsVolumeID", "(", "aws", ".", "StringValue", "(", "res", ".", "SnapshotId", ")", ")", "\n", "// apply tags", "if", "err", ":=", "c", ".", "tagging", ".", "createTags", "(", "c", ".", "ec2", ",", "string", "(", "awsID", ")", ",", "ResourceLifecycleOwned", ",", "*", "snapshotOptions", ".", "Tags", ")", ";", "err", "!=", "nil", "{", "_", ",", "delerr", ":=", "c", ".", "DeleteSnapshot", "(", "*", "res", ".", "SnapshotId", ")", "\n", "if", "delerr", "!=", "nil", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "*", "res", ".", "SnapshotId", ",", "delerr", ")", "\n", "}", "\n", "return", "\"", "\"", ",", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "*", "res", ".", "SnapshotId", ",", "err", ")", "\n", "}", "\n", "}", "\n", "return", "*", "res", ".", "SnapshotId", ",", "*", "res", ".", "State", ",", "nil", "\n\n", "}" ]

[ "CreateSnapshot", "creates", "an", "EBS", "volume", "snapshot" ]

[ "func", "(", "c", "*", "Cloud", ")", "DeleteSnapshot", "(", "snapshotID", "string", ")", "(", "bool", ",", "error", ")", "{", "request", ":=", "&", "ec2", ".", "DeleteSnapshotInput", "{", "}", "\n", "request", ".", "SnapshotId", "=", "aws", ".", "String", "(", "snapshotID", ")", "\n", "_", ",", "err", ":=", "c", ".", "ec2", ".", "DeleteSnapshot", "(", "request", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n\n", "return", "true", ",", "nil", "\n", "}" ]

[ "DeleteSnapshot", "deletes", "an", "EBS", "volume", "snapshot" ]

[ "func", "(", "c", "*", "Cloud", ")", "DescribeSnapshot", "(", "snapshotID", "string", ")", "(", "status", "string", ",", "isCompleted", "bool", ",", "err", "error", ")", "{", "request", ":=", "&", "ec2", ".", "DescribeSnapshotsInput", "{", "SnapshotIds", ":", "[", "]", "*", "string", "{", "aws", ".", "String", "(", "snapshotID", ")", ",", "}", ",", "}", "\n", "result", ",", "err", ":=", "c", ".", "ec2", ".", "DescribeSnapshots", "(", "request", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "false", ",", "err", "\n", "}", "\n", "if", "len", "(", "result", ")", "!=", "1", "{", "return", "\"", "\"", ",", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "result", ")", "\n", "}", "\n", "if", "result", "[", "0", "]", ".", "State", "==", "nil", "{", "return", "\"", "\"", ",", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "result", ")", "\n", "}", "\n", "if", "*", "result", "[", "0", "]", ".", "State", "==", "ec2", ".", "SnapshotStateCompleted", "{", "return", "*", "result", "[", "0", "]", ".", "State", ",", "true", ",", "nil", "\n", "}", "\n", "if", "*", "result", "[", "0", "]", ".", "State", "==", "ec2", ".", "SnapshotStateError", "{", "return", "*", "result", "[", "0", "]", ".", "State", ",", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "*", "result", "[", "0", "]", ".", "StateMessage", ")", "\n", "}", "\n", "if", "*", "result", "[", "0", "]", ".", "State", "==", "ec2", ".", "SnapshotStatePending", "{", "return", "*", "result", "[", "0", "]", ".", "State", ",", "false", ",", "nil", "\n", "}", "\n", "return", "*", "result", "[", "0", "]", ".", "State", ",", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}" ]

[ "DescribeSnapshot", "returns", "the", "status", "of", "the", "snapshot" ]

[ "func", "(", "c", "*", "Cloud", ")", "FindSnapshot", "(", "tags", "map", "[", "string", "]", "string", ")", "(", "[", "]", "string", ",", "[", "]", "string", ",", "error", ")", "{", "request", ":=", "&", "ec2", ".", "DescribeSnapshotsInput", "{", "}", "\n", "for", "k", ",", "v", ":=", "range", "tags", "{", "filter", ":=", "&", "ec2", ".", "Filter", "{", "}", "\n", "filter", ".", "SetName", "(", "k", ")", "\n", "filter", ".", "SetValues", "(", "[", "]", "*", "string", "{", "&", "v", "}", ")", "\n\n", "request", ".", "Filters", "=", "append", "(", "request", ".", "Filters", ",", "filter", ")", "\n", "}", "\n\n", "result", ",", "err", ":=", "c", ".", "ec2", ".", "DescribeSnapshots", "(", "request", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "var", "snapshotIDs", ",", "statuses", "[", "]", "string", "\n", "for", "_", ",", "snapshot", ":=", "range", "result", "{", "id", ":=", "*", "snapshot", ".", "SnapshotId", "\n", "status", ":=", "*", "snapshot", ".", "State", "\n", "glog", ".", "Infof", "(", "\"", "\"", ",", "id", ",", "status", ")", "\n", "snapshotIDs", "=", "append", "(", "snapshotIDs", ",", "id", ")", "\n", "statuses", "=", "append", "(", "statuses", ",", "status", ")", "\n", "}", "\n", "return", "snapshotIDs", ",", "statuses", ",", "nil", "\n", "}" ]

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

[ "func", "(", "c", "*", "Cloud", ")", "findSecurityGroup", "(", "securityGroupID", "string", ")", "(", "*", "ec2", ".", "SecurityGroup", ",", "error", ")", "{", "describeSecurityGroupsRequest", ":=", "&", "ec2", ".", "DescribeSecurityGroupsInput", "{", "GroupIds", ":", "[", "]", "*", "string", "{", "&", "securityGroupID", "}", ",", "}", "\n", "// We don't apply our tag filters because we are retrieving by ID", "groups", ",", "err", ":=", "c", ".", "ec2", ".", "DescribeSecurityGroups", "(", "describeSecurityGroupsRequest", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "len", "(", "groups", ")", "==", "0", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "if", "len", "(", "groups", ")", "!=", "1", "{", "// This should not be possible - ids should be unique", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "securityGroupID", ")", "\n", "}", "\n", "group", ":=", "groups", "[", "0", "]", "\n", "return", "group", ",", "nil", "\n", "}" ]

[ "Retrieves", "the", "specified", "security", "group", "from", "the", "AWS", "API", "or", "returns", "nil", "if", "not", "found" ]

[ "func", "(", "c", "*", "Cloud", ")", "setSecurityGroupIngress", "(", "securityGroupID", "string", ",", "permissions", "IPPermissionSet", ")", "(", "bool", ",", "error", ")", "{", "group", ",", "err", ":=", "c", ".", "findSecurityGroup", "(", "securityGroupID", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Warning", "(", "\"", "\"", ",", "err", ")", "\n", "return", "false", ",", "err", "\n", "}", "\n\n", "if", "group", "==", "nil", "{", "return", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "securityGroupID", ")", "\n", "}", "\n\n", "glog", ".", "V", "(", "2", ")", ".", "Infof", "(", "\"", "\"", ",", "securityGroupID", ",", "group", ".", "IpPermissions", ")", "\n\n", "actual", ":=", "NewIPPermissionSet", "(", "group", ".", "IpPermissions", "...", ")", "\n\n", "// EC2 groups rules together, for example combining:", "//", "// { Port=80, Range=[A] } and { Port=80, Range=[B] }", "//", "// into { Port=80, Range=[A,B] }", "//", "// We have to ungroup them, because otherwise the logic becomes really", "// complicated, and also because if we have Range=[A,B] and we try to", "// add Range=[A] then EC2 complains about a duplicate rule.", "permissions", "=", "permissions", ".", "Ungroup", "(", ")", "\n", "actual", "=", "actual", ".", "Ungroup", "(", ")", "\n\n", "remove", ":=", "actual", ".", "Difference", "(", "permissions", ")", "\n", "add", ":=", "permissions", ".", "Difference", "(", "actual", ")", "\n\n", "if", "add", ".", "Len", "(", ")", "==", "0", "&&", "remove", ".", "Len", "(", ")", "==", "0", "{", "return", "false", ",", "nil", "\n", "}", "\n\n", "// TODO: There is a limit in VPC of 100 rules per security group, so we", "// probably should try grouping or combining to fit under this limit.", "// But this is only used on the ELB security group currently, so it", "// would require (ports * CIDRS) > 100. Also, it isn't obvious exactly", "// how removing single permissions from compound rules works, and we", "// don't want to accidentally open more than intended while we're", "// applying changes.", "if", "add", ".", "Len", "(", ")", "!=", "0", "{", "glog", ".", "V", "(", "2", ")", ".", "Infof", "(", "\"", "\"", ",", "securityGroupID", ",", "add", ".", "List", "(", ")", ")", "\n\n", "request", ":=", "&", "ec2", ".", "AuthorizeSecurityGroupIngressInput", "{", "}", "\n", "request", ".", "GroupId", "=", "&", "securityGroupID", "\n", "request", ".", "IpPermissions", "=", "add", ".", "List", "(", ")", "\n", "_", ",", "err", "=", "c", ".", "ec2", ".", "AuthorizeSecurityGroupIngress", "(", "request", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "if", "remove", ".", "Len", "(", ")", "!=", "0", "{", "glog", ".", "V", "(", "2", ")", ".", "Infof", "(", "\"", "\"", ",", "securityGroupID", ",", "remove", ".", "List", "(", ")", ")", "\n\n", "request", ":=", "&", "ec2", ".", "RevokeSecurityGroupIngressInput", "{", "}", "\n", "request", ".", "GroupId", "=", "&", "securityGroupID", "\n", "request", ".", "IpPermissions", "=", "remove", ".", "List", "(", ")", "\n", "_", ",", "err", "=", "c", ".", "ec2", ".", "RevokeSecurityGroupIngress", "(", "request", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "return", "true", ",", "nil", "\n", "}" ]

[ "Makes", "sure", "the", "security", "group", "ingress", "is", "exactly", "the", "specified", "permissions", "Returns", "true", "if", "and", "only", "if", "changes", "were", "made", "The", "security", "group", "must", "already", "exist" ]

[ "func", "findSecurityGroupForInstance", "(", "instance", "*", "ec2", ".", "Instance", ",", "taggedSecurityGroups", "map", "[", "string", "]", "*", "ec2", ".", "SecurityGroup", ")", "(", "*", "ec2", ".", "GroupIdentifier", ",", "error", ")", "{", "instanceID", ":=", "aws", ".", "StringValue", "(", "instance", ".", "InstanceId", ")", "\n\n", "var", "tagged", "[", "]", "*", "ec2", ".", "GroupIdentifier", "\n", "var", "untagged", "[", "]", "*", "ec2", ".", "GroupIdentifier", "\n", "for", "_", ",", "group", ":=", "range", "instance", ".", "SecurityGroups", "{", "groupID", ":=", "aws", ".", "StringValue", "(", "group", ".", "GroupId", ")", "\n", "if", "groupID", "==", "\"", "\"", "{", "glog", ".", "Warningf", "(", "\"", "\"", ",", "instanceID", ",", "group", ")", "\n", "continue", "\n", "}", "\n", "_", ",", "isTagged", ":=", "taggedSecurityGroups", "[", "groupID", "]", "\n", "if", "isTagged", "{", "tagged", "=", "append", "(", "tagged", ",", "group", ")", "\n", "}", "else", "{", "untagged", "=", "append", "(", "untagged", ",", "group", ")", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "tagged", ")", ">", "0", "{", "// We create instances with one SG", "// If users create multiple SGs, they must tag one of them as being k8s owned", "if", "len", "(", "tagged", ")", "!=", "1", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "instanceID", ")", "\n", "}", "\n", "return", "tagged", "[", "0", "]", ",", "nil", "\n", "}", "\n\n", "if", "len", "(", "untagged", ")", ">", "0", "{", "// For back-compat, we will allow a single untagged SG", "if", "len", "(", "untagged", ")", "!=", "1", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "instanceID", ")", "\n", "}", "\n", "return", "untagged", "[", "0", "]", ",", "nil", "\n", "}", "\n\n", "glog", ".", "Warningf", "(", "\"", "\"", ",", "instanceID", ")", "\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "Returns", "the", "first", "security", "group", "for", "an", "instance", "or", "nil", "We", "only", "create", "instances", "with", "one", "security", "group", "so", "we", "don", "t", "expect", "multiple", "security", "groups", ".", "However", "if", "there", "are", "multiple", "security", "groups", "we", "will", "choose", "the", "one", "tagged", "with", "our", "cluster", "filter", ".", "Otherwise", "we", "will", "return", "an", "error", "." ]

[ "func", "(", "c", "*", "Cloud", ")", "getInstanceByID", "(", "instanceID", "string", ")", "(", "*", "ec2", ".", "Instance", ",", "error", ")", "{", "instances", ",", "err", ":=", "c", ".", "getInstancesByIDs", "(", "[", "]", "*", "string", "{", "&", "instanceID", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "len", "(", "instances", ")", "==", "0", "{", "return", "nil", ",", "cloudprovider", ".", "ErrInstanceNotFound", "\n", "}", "\n", "if", "len", "(", "instances", ")", ">", "1", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "instanceID", ")", "\n", "}", "\n\n", "return", "instances", "[", "instanceID", "]", ",", "nil", "\n", "}" ]

[ "Returns", "the", "instance", "with", "the", "specified", "ID" ]

[ "func", "(", "c", "*", "Cloud", ")", "getInstanceByNodeName", "(", "nodeName", "types", ".", "NodeName", ")", "(", "*", "ec2", ".", "Instance", ",", "error", ")", "{", "instance", ",", "err", ":=", "c", ".", "findInstanceByNodeName", "(", "nodeName", ")", "\n", "if", "err", "==", "nil", "&&", "instance", "==", "nil", "{", "return", "nil", ",", "cloudprovider", ".", "ErrInstanceNotFound", "\n", "}", "\n", "return", "instance", ",", "err", "\n", "}" ]

[ "Returns", "the", "instance", "with", "the", "specified", "node", "name", "Like", "findInstanceByNodeName", "but", "returns", "error", "if", "node", "not", "found" ]

[ "func", "NewGlusterfsProvisioner", "(", "config", "*", "rest", ".", "Config", ",", "client", "kubernetes", ".", "Interface", ")", "controller", ".", "Provisioner", "{", "klog", ".", "Infof", "(", "\"", "\"", ")", "\n", "return", "newGlusterfsProvisionerInternal", "(", "config", ",", "client", ")", "\n", "}" ]

[ "NewGlusterfsProvisioner", "creates", "a", "new", "glusterfs", "simple", "provisioner" ]

[ "func", "(", "cache", "*", "VolumeCache", ")", "GetPV", "(", "pvName", "string", ")", "(", "*", "v1", ".", "PersistentVolume", ",", "bool", ")", "{", "cache", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "cache", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "pv", ",", "exists", ":=", "cache", ".", "pvs", "[", "pvName", "]", "\n", "return", "pv", ",", "exists", "\n", "}" ]

[ "GetPV", "returns", "the", "PV", "object", "given", "the", "PV", "name" ]

[ "func", "(", "cache", "*", "VolumeCache", ")", "AddPV", "(", "pv", "*", "v1", ".", "PersistentVolume", ")", "{", "cache", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "cache", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "cache", ".", "pvs", "[", "pv", ".", "Name", "]", "=", "pv", "\n", "glog", ".", "Infof", "(", "\"", "\"", ",", "pv", ".", "Name", ")", "\n", "}" ]

[ "AddPV", "adds", "the", "PV", "object", "to", "the", "cache" ]

[ "func", "(", "cache", "*", "VolumeCache", ")", "DeletePV", "(", "pvName", "string", ")", "{", "cache", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "cache", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "delete", "(", "cache", ".", "pvs", ",", "pvName", ")", "\n", "glog", ".", "Infof", "(", "\"", "\"", ",", "pvName", ")", "\n", "}" ]

[ "DeletePV", "deletes", "the", "PV", "object", "from", "the", "cache" ]

[ "func", "(", "cache", "*", "VolumeCache", ")", "ListPVs", "(", ")", "[", "]", "*", "v1", ".", "PersistentVolume", "{", "cache", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "cache", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "pvs", ":=", "[", "]", "*", "v1", ".", "PersistentVolume", "{", "}", "\n", "for", "_", ",", "pv", ":=", "range", "cache", ".", "pvs", "{", "pvs", "=", "append", "(", "pvs", ",", "pv", ")", "\n", "}", "\n", "return", "pvs", "\n", "}" ]

[ "ListPVs", "returns", "a", "list", "of", "all", "the", "PVs", "in", "the", "cache" ]

[ "func", "Setup", "(", "ganeshaConfig", "string", ",", "gracePeriod", "uint", ")", "error", "{", "// Start rpcbind if it is not started yet", "cmd", ":=", "exec", ".", "Command", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "err", ":=", "cmd", ".", "Run", "(", ")", ";", "err", "!=", "nil", "{", "cmd", "=", "exec", ".", "Command", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "out", ",", "err", ":=", "cmd", ".", "CombinedOutput", "(", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ",", "out", ")", "\n", "}", "\n", "}", "\n\n", "cmd", "=", "exec", ".", "Command", "(", "\"", "\"", ")", "\n", "if", "out", ",", "err", ":=", "cmd", ".", "CombinedOutput", "(", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ",", "out", ")", "\n", "}", "\n\n", "// Start dbus, needed for ganesha dynamic exports", "cmd", "=", "exec", ".", "Command", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "out", ",", "err", ":=", "cmd", ".", "CombinedOutput", "(", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ",", "out", ")", "\n", "}", "\n\n", "err", ":=", "setRlimitNOFILE", "(", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// Use defaultGaneshaConfigContents if the ganeshaConfig doesn't exist yet", "if", "_", ",", "err", "=", "os", ".", "Stat", "(", "ganeshaConfig", ")", ";", "os", ".", "IsNotExist", "(", "err", ")", "{", "err", "=", "ioutil", ".", "WriteFile", "(", "ganeshaConfig", ",", "defaultGaneshaConfigContents", ",", "0600", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ganeshaConfig", ",", "err", ")", "\n", "}", "\n", "}", "\n", "err", "=", "setGracePeriod", "(", "ganeshaConfig", ",", "gracePeriod", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "err", "=", "setFsidDevice", "(", "ganeshaConfig", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Setup", "sets", "up", "various", "prerequisites", "and", "settings", "for", "the", "server", ".", "If", "an", "error", "is", "encountered", "at", "any", "point", "it", "returns", "it", "instantly" ]

[ "func", "NewGlusterBlockProvisioner", "(", "client", "kubernetes", ".", "Interface", ",", "id", "string", ")", "controller", ".", "Provisioner", "{", "return", "&", "glusterBlockProvisioner", "{", "client", ":", "client", ",", "identity", ":", "id", ",", "}", "\n", "}" ]

[ "NewGlusterBlockProvisioner", "create", "a", "new", "provisioner", "." ]

[ "func", "(", "p", "*", "glusterBlockProvisioner", ")", "createVolume", "(", "volSizeInt", "int", ",", "blockVol", "string", ",", "config", "*", "provisionerConfig", ")", "(", "*", "glusterBlockVolume", ",", "error", ")", "{", "blockRes", ":=", "&", "glusterBlockVolume", "{", "}", "\n", "sizeStr", ":=", "strconv", ".", "Itoa", "(", "volSizeInt", ")", "\n", "haCountStr", ":=", "strconv", ".", "Itoa", "(", "config", ".", "haCount", ")", "\n\n", "klog", ".", "V", "(", "2", ")", ".", "Infof", "(", "\"", "\"", ",", "volSizeInt", ",", "config", ")", "\n\n", "// Possible opModes are gluster-block and heketi:", "switch", "config", ".", "opMode", "{", "// An experimental/Test Mode:", "case", "glusterBlockOpmode", ":", "gBlockCreateErr", ":=", "p", ".", "glusterBlockExecCreate", "(", "blockRes", ",", "config", ",", "sizeStr", ",", "haCountStr", ",", "blockVol", ")", "\n", "if", "gBlockCreateErr", "!=", "nil", "{", "klog", ".", "Errorf", "(", "\"", "\"", ",", "gBlockCreateErr", ")", "\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "gBlockCreateErr", ")", "\n", "}", "\n\n", "case", "heketiOpmode", ":", "hBlockCreateErr", ":=", "p", ".", "heketiBlockVolCreate", "(", "blockRes", ",", "config", ",", "volSizeInt", ",", "haCountStr", ",", "blockVol", ")", "\n", "if", "hBlockCreateErr", "!=", "nil", "{", "klog", ".", "Errorf", "(", "\"", "\"", ",", "hBlockCreateErr", ")", "\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "hBlockCreateErr", ")", "\n", "}", "\n\n", "default", ":", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "provisionerName", ")", "\n", "}", "\n", "return", "blockRes", ",", "nil", "\n", "}" ]

[ "createVolume", "creates", "a", "gluster", "block", "volume", "i", ".", "e", ".", "the", "storage", "asset", "." ]

[ "func", "(", "p", "*", "glusterBlockProvisioner", ")", "sortTargetPortal", "(", "vol", "*", "iscsiSpec", ")", "error", "{", "if", "len", "(", "vol", ".", "Portals", ")", "==", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "len", "(", "vol", ".", "Portals", ")", "==", "1", "&&", "vol", ".", "Portals", "[", "0", "]", "!=", "\"", "\"", "{", "vol", ".", "TargetPortal", "=", "vol", ".", "Portals", "[", "0", "]", "\n", "vol", ".", "Portals", "=", "nil", "\n", "}", "else", "{", "portals", ":=", "vol", ".", "Portals", "\n", "vol", ".", "Portals", "=", "nil", "\n", "for", "_", ",", "v", ":=", "range", "portals", "{", "if", "v", "!=", "\"", "\"", "&&", "vol", ".", "TargetPortal", "==", "\"", "\"", "{", "vol", ".", "TargetPortal", "=", "v", "\n", "continue", "\n", "}", "else", "{", "vol", ".", "Portals", "=", "append", "(", "vol", ".", "Portals", ",", "v", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "sortTargetPortal", "extract", "TP" ]

[ "func", "(", "u", "*", "volumeUtil", ")", "IsBlock", "(", "fullPath", "string", ")", "(", "bool", ",", "error", ")", "{", "return", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}" ]

[ "IsBlock", "for", "unsupported", "platform", "returns", "error", "." ]

[ "func", "(", "name", "KubernetesVolumeID", ")", "mapToAWSVolumeID", "(", ")", "(", "awsVolumeID", ",", "error", ")", "{", "// name looks like aws://availability-zone/awsVolumeId", "// The original idea of the URL-style name was to put the AZ into the", "// host, so we could find the AZ immediately from the name without", "// querying the API. But it turns out we don't actually need it for", "// multi-AZ clusters, as we put the AZ into the labels on the PV instead.", "// However, if in future we want to support multi-AZ cluster", "// volume-awareness without using PersistentVolumes, we likely will", "// want the AZ in the host.", "s", ":=", "string", "(", "name", ")", "\n\n", "if", "!", "strings", ".", "HasPrefix", "(", "s", ",", "\"", "\"", ")", "{", "// Assume a bare aws volume id (vol-1234...)", "// Build a URL with an empty host (AZ)", "s", "=", "\"", "\"", "+", "\"", "\"", "+", "\"", "\"", "+", "s", "\n", "}", "\n", "url", ",", "err", ":=", "url", ".", "Parse", "(", "s", ")", "\n", "if", "err", "!=", "nil", "{", "// TODO: Maybe we should pass a URL into the Volume functions", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ",", "err", ")", "\n", "}", "\n", "if", "url", ".", "Scheme", "!=", "\"", "\"", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n\n", "awsID", ":=", "url", ".", "Path", "\n", "awsID", "=", "strings", ".", "Trim", "(", "awsID", ",", "\"", "\"", ")", "\n\n", "// We sanity check the resulting volume; the two known formats are", "// vol-12345678 and vol-12345678abcdef01", "// TODO: Regex match?", "if", "strings", ".", "Contains", "(", "awsID", ",", "\"", "\"", ")", "||", "!", "strings", ".", "HasPrefix", "(", "awsID", ",", "\"", "\"", ")", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n\n", "return", "awsVolumeID", "(", "awsID", ")", ",", "nil", "\n", "}" ]

[ "mapToAWSVolumeID", "extracts", "the", "awsVolumeID", "from", "the", "KubernetesVolumeID" ]

[ "func", "(", "os", "*", "OpenStack", ")", "LoadBalancer", "(", ")", "(", "cloudprovider", ".", "LoadBalancer", ",", "bool", ")", "{", "glog", ".", "V", "(", "4", ")", ".", "Info", "(", "\"", "\"", ")", "\n\n", "// TODO: Search for and support Rackspace loadbalancer API, and others.", "network", ",", "err", ":=", "os", ".", "NewNetworkV2", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "false", "\n", "}", "\n\n", "compute", ",", "err", ":=", "os", ".", "NewComputeV2", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "false", "\n", "}", "\n\n", "lbVersion", ":=", "os", ".", "lbOpts", ".", "LBVersion", "\n", "if", "lbVersion", "==", "\"", "\"", "{", "// No version specified, try newest supported by server", "netExts", ",", "err", ":=", "networkExtensions", "(", "network", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "false", "\n", "}", "\n\n", "if", "netExts", "[", "\"", "\"", "]", "{", "lbVersion", "=", "\"", "\"", "\n", "}", "else", "if", "netExts", "[", "\"", "\"", "]", "{", "lbVersion", "=", "\"", "\"", "\n", "}", "else", "{", "glog", ".", "Warningf", "(", "\"", "\"", ")", "\n", "return", "nil", ",", "false", "\n", "}", "\n", "glog", ".", "V", "(", "3", ")", ".", "Infof", "(", "\"", "\"", ",", "lbVersion", ")", "\n", "}", "\n\n", "glog", ".", "V", "(", "1", ")", ".", "Info", "(", "\"", "\"", ")", "\n\n", "if", "lbVersion", "==", "\"", "\"", "{", "return", "&", "LbaasV2", "{", "LoadBalancer", "{", "network", ",", "compute", ",", "os", ".", "lbOpts", "}", "}", ",", "true", "\n", "}", "else", "if", "lbVersion", "==", "\"", "\"", "{", "return", "&", "LbaasV1", "{", "LoadBalancer", "{", "network", ",", "compute", ",", "os", ".", "lbOpts", "}", "}", ",", "true", "\n", "}", "else", "{", "glog", ".", "Warningf", "(", "\"", "\\\"", "\\\"", "\"", ",", "lbVersion", ")", "\n", "return", "nil", ",", "false", "\n", "}", "\n", "}" ]

[ "LoadBalancer", "returns", "a", "load", "balancer" ]

[ "func", "(", "os", "*", "OpenStack", ")", "Routes", "(", ")", "(", "cloudprovider", ".", "Routes", ",", "bool", ")", "{", "glog", ".", "V", "(", "4", ")", ".", "Info", "(", "\"", "\"", ")", "\n\n", "network", ",", "err", ":=", "os", ".", "NewNetworkV2", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "false", "\n", "}", "\n\n", "netExts", ",", "err", ":=", "networkExtensions", "(", "network", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "false", "\n", "}", "\n\n", "if", "!", "netExts", "[", "\"", "\"", "]", "{", "glog", ".", "V", "(", "3", ")", ".", "Infof", "(", "\"", "\"", ")", "\n", "return", "nil", ",", "false", "\n", "}", "\n\n", "compute", ",", "err", ":=", "os", ".", "NewComputeV2", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "false", "\n", "}", "\n\n", "r", ",", "err", ":=", "NewRoutes", "(", "compute", ",", "network", ",", "os", ".", "routeOpts", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "false", "\n", "}", "\n\n", "glog", ".", "V", "(", "1", ")", ".", "Info", "(", "\"", "\"", ")", "\n\n", "return", "r", ",", "true", "\n", "}" ]

[ "Routes", "returns", "cloud", "provider", "routes" ]

[ "func", "(", "os", "*", "OpenStack", ")", "Zones", "(", ")", "(", "cloudprovider", ".", "Zones", ",", "bool", ")", "{", "glog", ".", "V", "(", "1", ")", ".", "Info", "(", "\"", "\"", ")", "\n\n", "return", "os", ",", "true", "\n", "}" ]

[ "Zones", "returns", "cloud", "provider", "zones" ]

[ "func", "(", "os", "*", "OpenStack", ")", "GetZone", "(", ")", "(", "cloudprovider", ".", "Zone", ",", "error", ")", "{", "md", ",", "err", ":=", "getMetadata", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "cloudprovider", ".", "Zone", "{", "}", ",", "err", "\n", "}", "\n\n", "zone", ":=", "cloudprovider", ".", "Zone", "{", "FailureDomain", ":", "md", ".", "AvailabilityZone", ",", "Region", ":", "os", ".", "region", ",", "}", "\n", "glog", ".", "V", "(", "1", ")", ".", "Infof", "(", "\"", "\"", ",", "zone", ")", "\n\n", "return", "zone", ",", "nil", "\n", "}" ]

[ "GetZone", "gets", "a", "zone", "from", "cloud", "provider" ]

[ "func", "NewVolumeSnapshotter", "(", "restClient", "*", "rest", ".", "RESTClient", ",", "scheme", "*", "runtime", ".", "Scheme", ",", "clientset", "kubernetes", ".", "Interface", ",", "asw", "cache", ".", "ActualStateOfWorld", ",", "volumePlugins", "*", "map", "[", "string", "]", "volume", ".", "Plugin", ")", "VolumeSnapshotter", "{", "return", "&", "volumeSnapshotter", "{", "restClient", ":", "restClient", ",", "coreClient", ":", "clientset", ",", "scheme", ":", "scheme", ",", "actualStateOfWorld", ":", "asw", ",", "runningOperation", ":", "goroutinemap", ".", "NewGoRoutineMap", "(", "defaultExponentialBackOffOnError", ")", ",", "volumePlugins", ":", "volumePlugins", ",", "}", "\n", "}" ]

[ "NewVolumeSnapshotter", "create", "a", "new", "VolumeSnapshotter" ]

[ "func", "(", "vs", "*", "volumeSnapshotter", ")", "getPVFromVolumeSnapshot", "(", "uniqueSnapshotName", "string", ",", "snapshot", "*", "crdv1", ".", "VolumeSnapshot", ")", "(", "*", "v1", ".", "PersistentVolume", ",", "error", ")", "{", "pvcName", ":=", "snapshot", ".", "Spec", ".", "PersistentVolumeClaimName", "\n", "if", "pvcName", "==", "\"", "\"", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "uniqueSnapshotName", ")", "\n", "}", "\n\n", "pvc", ",", "err", ":=", "vs", ".", "coreClient", ".", "CoreV1", "(", ")", ".", "PersistentVolumeClaims", "(", "snapshot", ".", "Metadata", ".", "Namespace", ")", ".", "Get", "(", "pvcName", ",", "metav1", ".", "GetOptions", "{", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "pvcName", ",", "err", ")", "\n", "}", "\n", "if", "pvc", ".", "Status", ".", "Phase", "!=", "v1", ".", "ClaimBound", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "pvcName", ")", "\n", "}", "\n\n", "pvName", ":=", "pvc", ".", "Spec", ".", "VolumeName", "\n", "pv", ",", "err", ":=", "vs", ".", "getPVFromName", "(", "pvName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "pvName", ",", "err", ")", "\n", "}", "\n", "return", "pv", ",", "nil", "\n", "}" ]

[ "Helper", "function", "to", "get", "PV", "from", "VolumeSnapshot" ]

[ "func", "(", "vs", "*", "volumeSnapshotter", ")", "getPVFromName", "(", "pvName", "string", ")", "(", "*", "v1", ".", "PersistentVolume", ",", "error", ")", "{", "return", "vs", ".", "coreClient", ".", "CoreV1", "(", ")", ".", "PersistentVolumes", "(", ")", ".", "Get", "(", "pvName", ",", "metav1", ".", "GetOptions", "{", "}", ")", "\n", "}" ]

[ "Helper", "function", "to", "get", "PV", "from", "PV", "name" ]

[ "func", "(", "vs", "*", "volumeSnapshotter", ")", "getSnapshotDataFromSnapshot", "(", "snapshot", "*", "crdv1", ".", "VolumeSnapshot", ")", "(", "*", "crdv1", ".", "VolumeSnapshotData", ",", "error", ")", "{", "var", "snapshotDataObj", "crdv1", ".", "VolumeSnapshotData", "\n", "snapshotDataName", ":=", "snapshot", ".", "Spec", ".", "SnapshotDataName", "\n", "if", "snapshotDataName", "==", "\"", "\"", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "err", ":=", "vs", ".", "restClient", ".", "Get", "(", ")", ".", "Name", "(", "snapshotDataName", ")", ".", "Resource", "(", "crdv1", ".", "VolumeSnapshotDataResourcePlural", ")", ".", "Do", "(", ")", ".", "Into", "(", "&", "snapshotDataObj", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "snapshotDataName", ",", "err", ")", "\n", "}", "\n", "return", "&", "snapshotDataObj", ",", "nil", "\n", "}" ]

[ "Helper", "function", "that", "looks", "up", "VolumeSnapshotData", "from", "a", "VolumeSnapshot" ]

[ "func", "(", "vs", "*", "volumeSnapshotter", ")", "updateSnapshotIfExists", "(", "uniqueSnapshotName", "string", ",", "snapshot", "*", "crdv1", ".", "VolumeSnapshot", ")", "(", "string", ",", "*", "crdv1", ".", "VolumeSnapshot", ",", "error", ")", "{", "snapshotName", ":=", "snapshot", ".", "Metadata", ".", "Name", "\n", "var", "snapshotDataObj", "*", "crdv1", ".", "VolumeSnapshotData", "\n", "var", "snapshotDataSource", "*", "crdv1", ".", "VolumeSnapshotDataSource", "\n", "var", "conditions", "*", "[", "]", "crdv1", ".", "VolumeSnapshotCondition", "\n", "var", "err", "error", "\n\n", "tags", ":=", "vs", ".", "findVolumeSnapshotMetadata", "(", "snapshot", ")", "\n", "// If there is no tag returned, snapshotting is not triggered yet, return new state", "if", "tags", "==", "nil", "{", "glog", ".", "Infof", "(", "\"", "\"", ",", "uniqueSnapshotName", ")", "\n", "return", "statusNew", ",", "snapshot", ",", "nil", "\n", "}", "\n", "// Check whether snapshotData object is already created or not. If yes, snapshot is already", "// triggered through cloud provider, bind it and return pending state", "if", "snapshotDataObj", "=", "vs", ".", "getSnapshotDataFromSnapshotName", "(", "uniqueSnapshotName", ")", ";", "snapshotDataObj", "!=", "nil", "{", "glog", ".", "Infof", "(", "\"", "\"", ",", "snapshotDataObj", ".", "Metadata", ".", "Name", ",", "uniqueSnapshotName", ")", "\n", "snapshotObj", ",", "err", ":=", "vs", ".", "bindandUpdateVolumeSnapshot", "(", "snapshot", ",", "snapshotDataObj", ".", "Metadata", ".", "Name", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "statusError", ",", "snapshot", ",", "err", "\n", "}", "\n", "return", "statusPending", ",", "snapshotObj", ",", "nil", "\n", "}", "\n", "// Find snapshot through cloud provider by existing tags, and create VolumeSnapshotData if such snapshot is found", "snapshotDataSource", ",", "conditions", ",", "err", "=", "vs", ".", "findSnapshotByTags", "(", "snapshotName", ",", "snapshot", ")", "\n", "if", "err", "!=", "nil", "{", "return", "statusNew", ",", "snapshot", ",", "nil", "\n", "}", "\n", "// Snapshot is found. Create VolumeSnapshotData, bind VolumeSnapshotData to VolumeSnapshot, and update VolumeSnapshot status", "glog", ".", "Infof", "(", "\"", "\"", ",", "uniqueSnapshotName", ")", "\n", "pvName", ",", "ok", ":=", "snapshot", ".", "Metadata", ".", "Labels", "[", "pvNameLabel", "]", "\n", "if", "!", "ok", "{", "return", "statusError", ",", "snapshot", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "snapshotDataObj", ",", "err", "=", "vs", ".", "createVolumeSnapshotData", "(", "snapshotName", ",", "pvName", ",", "snapshotDataSource", ",", "conditions", ")", "\n", "if", "err", "!=", "nil", "{", "return", "statusError", ",", "snapshot", ",", "err", "\n", "}", "\n", "glog", ".", "Infof", "(", "\"", "\"", ",", "uniqueSnapshotName", ")", "\n", "snapshotObj", ",", "err", ":=", "vs", ".", "bindandUpdateVolumeSnapshot", "(", "snapshot", ",", "snapshotDataObj", ".", "Metadata", ".", "Name", ",", "conditions", ")", "\n", "if", "err", "!=", "nil", "{", "return", "statusError", ",", "nil", ",", "err", "\n", "}", "\n", "return", "statusPending", ",", "snapshotObj", ",", "nil", "\n", "}" ]

[ "Exame", "the", "given", "snapshot", "in", "detail", "and", "then", "return", "the", "status" ]

[ "func", "(", "vs", "*", "volumeSnapshotter", ")", "syncSnapshot", "(", "uniqueSnapshotName", "string", ",", "snapshot", "*", "crdv1", ".", "VolumeSnapshot", ")", "func", "(", ")", "error", "{", "return", "func", "(", ")", "error", "{", "snapshotObj", ":=", "snapshot", "\n", "status", ":=", "vs", ".", "getSimplifiedSnapshotStatus", "(", "snapshot", ".", "Status", ".", "Conditions", ")", "\n", "var", "err", "error", "\n", "// When the condition is new, it is still possible that snapshot is already triggered but has not yet updated the condition.", "// Check the metadata and available VolumeSnapshotData objects and update the snapshot accordingly", "if", "status", "==", "statusNew", "{", "status", ",", "snapshotObj", ",", "err", "=", "vs", ".", "updateSnapshotIfExists", "(", "uniqueSnapshotName", ",", "snapshot", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "switch", "status", "{", "case", "statusReady", ":", "glog", ".", "Infof", "(", "\"", "\"", ",", "uniqueSnapshotName", ")", "\n", "vs", ".", "actualStateOfWorld", ".", "AddSnapshot", "(", "snapshot", ")", "\n", "return", "nil", "\n", "case", "statusError", ":", "glog", ".", "Infof", "(", "\"", "\"", ",", "uniqueSnapshotName", ")", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "uniqueSnapshotName", ")", "\n", "case", "statusPending", ":", "glog", ".", "V", "(", "4", ")", ".", "Infof", "(", "\"", "\"", ",", "uniqueSnapshotName", ")", "\n", "// Query the volume plugin for the status of the snapshot with snapshot id", "// from VolumeSnapshotData object.", "snapshotDataObj", ",", "err", ":=", "vs", ".", "getSnapshotDataFromSnapshot", "(", "snapshotObj", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "err", "=", "vs", ".", "waitForSnapshot", "(", "uniqueSnapshotName", ",", "snapshotObj", ",", "snapshotDataObj", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "uniqueSnapshotName", ",", "err", ")", "\n", "}", "\n", "glog", ".", "Infof", "(", "\"", "\"", ",", "uniqueSnapshotName", ")", "\n", "return", "nil", "\n", "case", "statusNew", ":", "glog", ".", "Infof", "(", "\"", "\"", ",", "uniqueSnapshotName", ")", "\n", "err", "=", "vs", ".", "createSnapshot", "(", "uniqueSnapshotName", ",", "snapshotObj", ")", "\n", "return", "err", "\n", "}", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "uniqueSnapshotName", ",", "status", ")", "\n", "}", "\n", "}" ]

[ "Below", "are", "the", "closures", "meant", "to", "build", "the", "functions", "for", "the", "GoRoutineMap", "operations", ".", "syncSnapshot", "is", "the", "main", "controller", "method", "to", "decide", "what", "to", "do", "to", "create", "a", "snapshot", "." ]

[ "func", "(", "vs", "*", "volumeSnapshotter", ")", "createSnapshot", "(", "uniqueSnapshotName", "string", ",", "snapshot", "*", "crdv1", ".", "VolumeSnapshot", ")", "error", "{", "var", "snapshotDataSource", "*", "crdv1", ".", "VolumeSnapshotDataSource", "\n", "var", "snapStatus", "*", "[", "]", "crdv1", ".", "VolumeSnapshotCondition", "\n", "var", "err", "error", "\n", "var", "tags", "*", "map", "[", "string", "]", "string", "\n", "glog", ".", "Infof", "(", "\"", "\"", ",", "uniqueSnapshotName", ")", "\n", "pv", ",", "err", ":=", "vs", ".", "getPVFromVolumeSnapshot", "(", "uniqueSnapshotName", ",", "snapshot", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "glog", ".", "Infof", "(", "\"", "\"", ",", "uniqueSnapshotName", ")", "\n", "tags", ",", "err", "=", "vs", ".", "updateVolumeSnapshotMetadata", "(", "snapshot", ",", "pv", ".", "Name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "uniqueSnapshotName", ",", "err", ")", "\n", "}", "\n\n", "snapshotDataSource", ",", "snapStatus", ",", "err", "=", "vs", ".", "takeSnapshot", "(", "snapshot", ",", "pv", ",", "tags", ")", "\n", "if", "err", "!=", "nil", "||", "snapshotDataSource", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "pv", ".", "Name", ",", "err", ")", "\n", "}", "\n\n", "glog", ".", "Infof", "(", "\"", "\"", ",", "uniqueSnapshotName", ")", "\n", "snapshotDataObj", ",", "err", ":=", "vs", ".", "createVolumeSnapshotData", "(", "uniqueSnapshotName", ",", "pv", ".", "Name", ",", "snapshotDataSource", ",", "snapStatus", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "glog", ".", "Infof", "(", "\"", "\"", ",", "uniqueSnapshotName", ")", "\n", "snapshotObj", ",", "err", ":=", "vs", ".", "bindandUpdateVolumeSnapshot", "(", "snapshot", ",", "snapshotDataObj", ".", "Metadata", ".", "Name", ",", "snapStatus", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "uniqueSnapshotName", ",", "err", ")", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "uniqueSnapshotName", ")", "\n", "}", "\n\n", "// Waiting for snapshot to be ready", "err", "=", "vs", ".", "waitForSnapshot", "(", "uniqueSnapshotName", ",", "snapshotObj", ",", "snapshotDataObj", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "uniqueSnapshotName", ",", "err", ")", "\n", "}", "\n", "glog", ".", "Infof", "(", "\"", "\"", ",", "uniqueSnapshotName", ")", "\n", "return", "nil", "\n", "}" ]

[ "The", "function", "goes", "through", "the", "whole", "snapshot", "creation", "process", ".", "1", ".", "Update", "VolumeSnapshot", "metadata", "to", "include", "the", "snapshotted", "PV", "name", "timestamp", "and", "snapshot", "uid", "also", "generate", "tag", "for", "cloud", "provider", "2", ".", "Trigger", "the", "snapshot", "through", "cloud", "provider", "and", "attach", "the", "tag", "to", "the", "snapshot", ".", "3", ".", "Create", "the", "VolumeSnapshotData", "object", "with", "the", "snapshot", "id", "information", "returned", "from", "step", "2", ".", "4", ".", "Bind", "the", "VolumeSnapshot", "and", "VolumeSnapshotData", "object", "5", ".", "Query", "the", "snapshot", "status", "through", "cloud", "provider", "and", "update", "the", "status", "until", "snapshot", "is", "ready", "or", "fails", "." ]

[ "func", "(", "vs", "*", "volumeSnapshotter", ")", "updateVolumeSnapshotMetadata", "(", "snapshot", "*", "crdv1", ".", "VolumeSnapshot", ",", "pvName", "string", ")", "(", "*", "map", "[", "string", "]", "string", ",", "error", ")", "{", "glog", ".", "Infof", "(", "\"", "\"", ")", "\n", "var", "snapshotObj", "crdv1", ".", "VolumeSnapshot", "\n", "// Need to get a fresh copy of the VolumeSnapshot from the API server", "err", ":=", "vs", ".", "restClient", ".", "Get", "(", ")", ".", "Name", "(", "snapshot", ".", "Metadata", ".", "Name", ")", ".", "Resource", "(", "crdv1", ".", "VolumeSnapshotResourcePlural", ")", ".", "Namespace", "(", "snapshot", ".", "Metadata", ".", "Namespace", ")", ".", "Do", "(", ")", ".", "Into", "(", "&", "snapshotObj", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "snapshot", ".", "Metadata", ".", "Name", ",", "err", ")", "\n", "}", "\n\n", "// Copy the snapshot object before updating it", "snapshotCopy", ":=", "snapshotObj", ".", "DeepCopy", "(", ")", "\n\n", "if", "snapshotCopy", ".", "Metadata", ".", "Labels", "==", "nil", "{", "snapshotCopy", ".", "Metadata", ".", "Labels", "=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "}", "\n", "snapshotCopy", ".", "Metadata", ".", "Labels", "[", "snapshotMetadataTimeStamp", "]", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "time", ".", "Now", "(", ")", ".", "UnixNano", "(", ")", ")", "\n", "snapshotCopy", ".", "Metadata", ".", "Labels", "[", "snapshotMetadataPVName", "]", "=", "pvName", "\n", "glog", ".", "Infof", "(", "\"", "\"", ",", "snapshotCopy", ".", "Metadata", ".", "UID", ",", "snapshotCopy", ".", "Metadata", ".", "Name", ",", "snapshotCopy", ".", "Metadata", ".", "Namespace", ",", "snapshotCopy", ".", "Metadata", ".", "Labels", ")", "\n\n", "// TODO: Use Patch instead of Put to update the object?", "var", "result", "crdv1", ".", "VolumeSnapshot", "\n", "err", "=", "vs", ".", "restClient", ".", "Put", "(", ")", ".", "Name", "(", "snapshot", ".", "Metadata", ".", "Name", ")", ".", "Resource", "(", "crdv1", ".", "VolumeSnapshotResourcePlural", ")", ".", "Namespace", "(", "snapshot", ".", "Metadata", ".", "Namespace", ")", ".", "Body", "(", "snapshotCopy", ")", ".", "Do", "(", ")", ".", "Into", "(", "&", "result", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "snapshot", ".", "Metadata", ".", "Namespace", ",", "snapshot", ".", "Metadata", ".", "Name", ",", "err", ")", "\n", "}", "\n\n", "cloudTags", ":=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "cloudTags", "[", "CloudSnapshotCreatedForVolumeSnapshotNamespaceTag", "]", "=", "result", ".", "Metadata", ".", "Namespace", "\n", "cloudTags", "[", "CloudSnapshotCreatedForVolumeSnapshotNameTag", "]", "=", "result", ".", "Metadata", ".", "Name", "\n", "cloudTags", "[", "CloudSnapshotCreatedForVolumeSnapshotUIDTag", "]", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "result", ".", "Metadata", ".", "UID", ")", "\n", "cloudTags", "[", "CloudSnapshotCreatedForVolumeSnapshotTimestampTag", "]", "=", "result", ".", "Metadata", ".", "Labels", "[", "snapshotMetadataTimeStamp", "]", "\n\n", "glog", ".", "Infof", "(", "\"", "\"", ",", "cloudTags", ")", "\n", "return", "&", "cloudTags", ",", "nil", "\n", "}" ]

[ "Update", "VolumeSnapshot", "object", "with", "current", "timestamp", "and", "associated", "PersistentVolume", "name", "in", "object", "s", "metadata" ]

[ "func", "(", "vs", "*", "volumeSnapshotter", ")", "propagateVolumeSnapshotCondition", "(", "snapshotDataName", "string", ",", "condition", "*", "crdv1", ".", "VolumeSnapshotCondition", ")", "error", "{", "var", "snapshotDataObj", "crdv1", ".", "VolumeSnapshotData", "\n", "err", ":=", "vs", ".", "restClient", ".", "Get", "(", ")", ".", "Name", "(", "snapshotDataName", ")", ".", "Resource", "(", "crdv1", ".", "VolumeSnapshotDataResourcePlural", ")", ".", "Do", "(", ")", ".", "Into", "(", "&", "snapshotDataObj", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "newCondition", ":=", "&", "crdv1", ".", "VolumeSnapshotDataCondition", "{", "Type", ":", "(", "crdv1", ".", "VolumeSnapshotDataConditionType", ")", "(", "condition", ".", "Type", ")", ",", "Status", ":", "condition", ".", "Status", ",", "Message", ":", "condition", ".", "Message", ",", "LastTransitionTime", ":", "condition", ".", "LastTransitionTime", ",", "}", "\n", "oldStatus", ":=", "snapshotDataObj", ".", "Status", ".", "DeepCopy", "(", ")", "\n\n", "status", ":=", "snapshotDataObj", ".", "Status", "\n", "isEqual", ":=", "false", "\n", "if", "oldStatus", ".", "Conditions", "==", "nil", "||", "len", "(", "oldStatus", ".", "Conditions", ")", "==", "0", "||", "newCondition", ".", "Type", "!=", "oldStatus", ".", "Conditions", "[", "len", "(", "oldStatus", ".", "Conditions", ")", "-", "1", "]", ".", "Type", "{", "status", ".", "Conditions", "=", "append", "(", "status", ".", "Conditions", ",", "*", "newCondition", ")", "\n", "}", "else", "{", "oldCondition", ":=", "oldStatus", ".", "Conditions", "[", "len", "(", "oldStatus", ".", "Conditions", ")", "-", "1", "]", "\n", "if", "newCondition", ".", "Status", "==", "oldCondition", ".", "Status", "{", "newCondition", ".", "LastTransitionTime", "=", "oldCondition", ".", "LastTransitionTime", "\n", "}", "\n", "status", ".", "Conditions", "[", "len", "(", "status", ".", "Conditions", ")", "-", "1", "]", "=", "*", "newCondition", "\n", "isEqual", "=", "newCondition", ".", "Type", "==", "oldCondition", ".", "Type", "&&", "newCondition", ".", "Status", "==", "oldCondition", ".", "Status", "&&", "newCondition", ".", "Reason", "==", "oldCondition", ".", "Reason", "&&", "newCondition", ".", "Message", "==", "oldCondition", ".", "Message", "&&", "newCondition", ".", "LastTransitionTime", ".", "Equal", "(", "&", "oldCondition", ".", "LastTransitionTime", ")", "\n", "}", "\n", "if", "!", "isEqual", "{", "var", "newSnapshotDataObj", "crdv1", ".", "VolumeSnapshotData", "\n", "snapshotDataObj", ".", "Status", "=", "status", "\n", "if", "snapshotDataObj", ".", "Status", ".", "CreationTimestamp", ".", "IsZero", "(", ")", "&&", "newCondition", ".", "Type", "==", "crdv1", ".", "VolumeSnapshotDataConditionReady", "{", "snapshotDataObj", ".", "Status", ".", "CreationTimestamp", "=", "newCondition", ".", "LastTransitionTime", "\n", "}", "\n", "err", "=", "vs", ".", "restClient", ".", "Put", "(", ")", ".", "Name", "(", "snapshotDataName", ")", ".", "Resource", "(", "crdv1", ".", "VolumeSnapshotDataResourcePlural", ")", ".", "Body", "(", "&", "snapshotDataObj", ")", ".", "Do", "(", ")", ".", "Into", "(", "&", "newSnapshotDataObj", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "glog", ".", "Infof", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Propagates", "the", "VolumeSnapshot", "condition", "to", "VolumeSnapshotData" ]

[ "func", "(", "vs", "*", "volumeSnapshotter", ")", "UpdateVolumeSnapshotStatus", "(", "snapshot", "*", "crdv1", ".", "VolumeSnapshot", ",", "condition", "*", "crdv1", ".", "VolumeSnapshotCondition", ")", "(", "*", "crdv1", ".", "VolumeSnapshot", ",", "error", ")", "{", "var", "snapshotObj", "crdv1", ".", "VolumeSnapshot", "\n\n", "err", ":=", "vs", ".", "restClient", ".", "Get", "(", ")", ".", "Name", "(", "snapshot", ".", "Metadata", ".", "Name", ")", ".", "Resource", "(", "crdv1", ".", "VolumeSnapshotResourcePlural", ")", ".", "Namespace", "(", "snapshot", ".", "Metadata", ".", "Namespace", ")", ".", "Do", "(", ")", ".", "Into", "(", "&", "snapshotObj", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "oldStatus", ":=", "snapshotObj", ".", "Status", ".", "DeepCopy", "(", ")", "\n\n", "status", ":=", "snapshotObj", ".", "Status", "\n", "isEqual", ":=", "false", "\n", "if", "oldStatus", ".", "Conditions", "==", "nil", "||", "len", "(", "oldStatus", ".", "Conditions", ")", "==", "0", "||", "condition", ".", "Type", "!=", "oldStatus", ".", "Conditions", "[", "len", "(", "oldStatus", ".", "Conditions", ")", "-", "1", "]", ".", "Type", "{", "status", ".", "Conditions", "=", "append", "(", "status", ".", "Conditions", ",", "*", "condition", ")", "\n", "}", "else", "{", "oldCondition", ":=", "oldStatus", ".", "Conditions", "[", "len", "(", "oldStatus", ".", "Conditions", ")", "-", "1", "]", "\n", "if", "condition", ".", "Status", "==", "oldCondition", ".", "Status", "{", "condition", ".", "LastTransitionTime", "=", "oldCondition", ".", "LastTransitionTime", "\n", "}", "\n", "status", ".", "Conditions", "[", "len", "(", "status", ".", "Conditions", ")", "-", "1", "]", "=", "*", "condition", "\n", "isEqual", "=", "condition", ".", "Type", "==", "oldCondition", ".", "Type", "&&", "condition", ".", "Status", "==", "oldCondition", ".", "Status", "&&", "condition", ".", "Reason", "==", "oldCondition", ".", "Reason", "&&", "condition", ".", "Message", "==", "oldCondition", ".", "Message", "&&", "condition", ".", "LastTransitionTime", ".", "Equal", "(", "&", "oldCondition", ".", "LastTransitionTime", ")", "\n", "}", "\n\n", "if", "!", "isEqual", "{", "var", "newSnapshotObj", "crdv1", ".", "VolumeSnapshot", "\n", "snapshotObj", ".", "Status", "=", "status", "\n", "err", "=", "vs", ".", "restClient", ".", "Put", "(", ")", ".", "Name", "(", "snapshot", ".", "Metadata", ".", "Name", ")", ".", "Resource", "(", "crdv1", ".", "VolumeSnapshotResourcePlural", ")", ".", "Namespace", "(", "snapshot", ".", "Metadata", ".", "Namespace", ")", ".", "Body", "(", "&", "snapshotObj", ")", ".", "Do", "(", ")", ".", "Into", "(", "&", "newSnapshotObj", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "glog", ".", "Infof", "(", "\"", "\"", ",", "newSnapshotObj", ")", "\n", "err", "=", "vs", ".", "propagateVolumeSnapshotCondition", "(", "snapshotObj", ".", "Spec", ".", "SnapshotDataName", ",", "&", "snapshotObj", ".", "Status", ".", "Conditions", "[", "len", "(", "snapshotObj", ".", "Status", ".", "Conditions", ")", "-", "1", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "newSnapshotObj", ",", "nil", "\n", "}", "\n\n", "return", "snapshot", ",", "nil", "\n", "}" ]

[ "Update", "VolumeSnapshot", "status", "if", "the", "condition", "is", "changed", "." ]

[ "func", "(", "vs", "*", "volumeSnapshotter", ")", "bindandUpdateVolumeSnapshot", "(", "snapshot", "*", "crdv1", ".", "VolumeSnapshot", ",", "snapshotDataName", "string", ",", "status", "*", "[", "]", "crdv1", ".", "VolumeSnapshotCondition", ")", "(", "*", "crdv1", ".", "VolumeSnapshot", ",", "error", ")", "{", "var", "snapshotObj", "crdv1", ".", "VolumeSnapshot", "\n\n", "glog", ".", "Infof", "(", "\"", "\"", ")", "\n", "// Get a fresh copy of the VolumeSnapshot from the API server", "glog", ".", "Infof", "(", "\"", "\"", ",", "snapshot", ".", "Metadata", ".", "Namespace", ",", "snapshot", ".", "Metadata", ".", "Name", ")", "\n", "err", ":=", "vs", ".", "restClient", ".", "Get", "(", ")", ".", "Name", "(", "snapshot", ".", "Metadata", ".", "Name", ")", ".", "Resource", "(", "crdv1", ".", "VolumeSnapshotResourcePlural", ")", ".", "Namespace", "(", "snapshot", ".", "Metadata", ".", "Namespace", ")", ".", "Do", "(", ")", ".", "Into", "(", "&", "snapshotObj", ")", "\n\n", "uniqueSnapshotName", ":=", "cache", ".", "MakeSnapshotName", "(", "snapshot", ")", "\n", "// TODO: Is copy needed here?", "snapshotCopy", ":=", "snapshotObj", ".", "DeepCopy", "(", ")", "\n\n", "snapshotCopy", ".", "Spec", ".", "SnapshotDataName", "=", "snapshotDataName", "\n", "if", "status", "!=", "nil", "{", "snapshotCopy", ".", "Status", ".", "Conditions", "=", "*", "status", "\n", "}", "\n", "glog", ".", "Infof", "(", "\"", "\"", ",", "snapshotCopy", ")", "\n", "// TODO: Make diff of the two objects and then use restClient.Patch to update it", "var", "result", "crdv1", ".", "VolumeSnapshot", "\n", "err", "=", "vs", ".", "restClient", ".", "Put", "(", ")", ".", "Name", "(", "snapshot", ".", "Metadata", ".", "Name", ")", ".", "Resource", "(", "crdv1", ".", "VolumeSnapshotResourcePlural", ")", ".", "Namespace", "(", "snapshot", ".", "Metadata", ".", "Namespace", ")", ".", "Body", "(", "snapshotCopy", ")", ".", "Do", "(", ")", ".", "Into", "(", "&", "result", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "uniqueSnapshotName", ",", "err", ")", "\n", "}", "\n\n", "return", "&", "result", ",", "nil", "\n", "}" ]

[ "Bind", "the", "VolumeSnapshot", "and", "VolumeSnapshotData", "and", "udpate", "the", "status" ]

[ "func", "(", "p", "*", "nfsProvisioner", ")", "getClassForVolume", "(", "pv", "*", "v1", ".", "PersistentVolume", ")", "(", "*", "storage", ".", "StorageClass", ",", "error", ")", "{", "if", "p", ".", "client", "==", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "className", ":=", "helper", ".", "GetPersistentVolumeClass", "(", "pv", ")", "\n", "if", "className", "==", "\"", "\"", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "class", ",", "err", ":=", "p", ".", "client", ".", "StorageV1", "(", ")", ".", "StorageClasses", "(", ")", ".", "Get", "(", "className", ",", "metav1", ".", "GetOptions", "{", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "class", ",", "nil", "\n", "}" ]

[ "getClassForVolume", "returns", "StorageClass" ]

[ "func", "NewDesiredStateOfWorldPopulator", "(", "loopSleepDuration", "time", ".", "Duration", ",", "listSnapshotsRetryDuration", "time", ".", "Duration", ",", "snapshotStore", "k8scache", ".", "Store", ",", "desiredStateOfWorld", "cache", ".", "DesiredStateOfWorld", ")", "DesiredStateOfWorldPopulator", "{", "return", "&", "desiredStateOfWorldPopulator", "{", "loopSleepDuration", ":", "loopSleepDuration", ",", "listSnapshotsRetryDuration", ":", "listSnapshotsRetryDuration", ",", "desiredStateOfWorld", ":", "desiredStateOfWorld", ",", "snapshotStore", ":", "snapshotStore", ",", "}", "\n", "}" ]

[ "NewDesiredStateOfWorldPopulator", "returns", "a", "new", "instance", "of", "DesiredStateOfWorldPopulator", ".", "loopSleepDuration", "-", "the", "amount", "of", "time", "the", "populator", "loop", "sleeps", "between", "successive", "executions", "desiredStateOfWorld", "-", "the", "cache", "to", "populate" ]

[ "func", "(", "plugin", "*", "flexProvisioner", ")", "NewDriverCall", "(", "execPath", ",", "command", "string", ")", "*", "DriverCall", "{", "return", "plugin", ".", "NewDriverCallWithTimeout", "(", "execPath", ",", "command", ",", "0", ")", "\n", "}" ]

[ "NewDriverCall", "initialize", "the", "DriverCall" ]

[ "func", "(", "plugin", "*", "flexProvisioner", ")", "NewDriverCallWithTimeout", "(", "execPath", ",", "command", "string", ",", "timeout", "time", ".", "Duration", ")", "*", "DriverCall", "{", "return", "&", "DriverCall", "{", "Execpath", ":", "execPath", ",", "Command", ":", "command", ",", "Timeout", ":", "timeout", ",", "plugin", ":", "plugin", ",", "args", ":", "[", "]", "string", "{", "command", "}", ",", "}", "\n", "}" ]

[ "NewDriverCallWithTimeout", "return", "the", "DriverCall", "with", "timeout" ]

[ "func", "(", "dc", "*", "DriverCall", ")", "AppendSpec", "(", "volumeOptions", ",", "extraOptions", "map", "[", "string", "]", "string", ")", "error", "{", "optionsForDriver", ",", "err", ":=", "NewOptionsForDriver", "(", "volumeOptions", ",", "extraOptions", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "jsonBytes", ",", "err", ":=", "json", ".", "Marshal", "(", "optionsForDriver", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "dc", ".", "Append", "(", "string", "(", "jsonBytes", ")", ")", "\n", "return", "nil", "\n", "}" ]

[ "AppendSpec", "add", "all", "option", "parameters", "to", "DriverCall" ]

[ "func", "(", "dc", "*", "DriverCall", ")", "Run", "(", ")", "(", "*", "DriverStatus", ",", "error", ")", "{", "cmd", ":=", "dc", ".", "plugin", ".", "runner", ".", "Command", "(", "dc", ".", "Execpath", ",", "dc", ".", "args", "...", ")", "\n\n", "timeout", ":=", "false", "\n", "if", "dc", ".", "Timeout", ">", "0", "{", "timer", ":=", "time", ".", "AfterFunc", "(", "dc", ".", "Timeout", ",", "func", "(", ")", "{", "timeout", "=", "true", "\n", "cmd", ".", "Stop", "(", ")", "\n", "}", ")", "\n", "defer", "timer", ".", "Stop", "(", ")", "\n", "}", "\n\n", "output", ",", "execErr", ":=", "cmd", ".", "CombinedOutput", "(", ")", "\n", "if", "execErr", "!=", "nil", "{", "if", "timeout", "{", "return", "nil", ",", "ErrorTimeout", "\n", "}", "\n", "_", ",", "err", ":=", "handleCmdResponse", "(", "dc", ".", "Command", ",", "output", ")", "\n", "if", "err", "==", "nil", "{", "klog", ".", "Errorf", "(", "\"", "\"", ",", "dc", ".", "Execpath", ",", "execErr", ")", "\n", "return", "nil", ",", "execErr", "\n", "}", "\n\n", "klog", ".", "Warningf", "(", "\"", "\"", ",", "dc", ".", "Execpath", ",", "dc", ".", "args", ",", "execErr", ".", "Error", "(", ")", ",", "output", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "status", ",", "err", ":=", "handleCmdResponse", "(", "dc", ".", "Command", ",", "output", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "status", ",", "nil", "\n", "}" ]

[ "Run", "the", "command", "with", "option", "parameters" ]

[ "func", "NewOptionsForDriver", "(", "volumeOptions", ",", "extraOptions", "map", "[", "string", "]", "string", ")", "(", "OptionsForDriver", ",", "error", ")", "{", "options", ":=", "map", "[", "string", "]", "string", "{", "}", "\n\n", "for", "key", ",", "value", ":=", "range", "extraOptions", "{", "options", "[", "key", "]", "=", "value", "\n", "}", "\n\n", "for", "key", ",", "value", ":=", "range", "volumeOptions", "{", "options", "[", "key", "]", "=", "value", "\n", "}", "\n\n", "return", "OptionsForDriver", "(", "options", ")", ",", "nil", "\n", "}" ]

[ "NewOptionsForDriver", "assemble", "all", "option", "parameters" ]

[ "func", "NewJobController", "(", "labelmap", "map", "[", "string", "]", "string", ",", "config", "*", "common", ".", "RuntimeConfig", ")", "(", "JobController", ",", "error", ")", "{", "namespace", ":=", "config", ".", "Namespace", "\n", "queue", ":=", "workqueue", ".", "NewRateLimitingQueue", "(", "workqueue", ".", "DefaultControllerRateLimiter", "(", ")", ")", "\n", "labelset", ":=", "labels", ".", "Set", "(", "labelmap", ")", "\n", "optionsModifier", ":=", "func", "(", "options", "*", "meta_v1", ".", "ListOptions", ")", "{", "options", ".", "LabelSelector", "=", "labels", ".", "SelectorFromSet", "(", "labelset", ")", ".", "String", "(", ")", "\n", "}", "\n\n", "informer", ":=", "config", ".", "InformerFactory", ".", "InformerFor", "(", "&", "batch_v1", ".", "Job", "{", "}", ",", "func", "(", "client", "kubernetes", ".", "Interface", ",", "resyncPeriod", "time", ".", "Duration", ")", "cache", ".", "SharedIndexInformer", "{", "return", "cache", ".", "NewSharedIndexInformer", "(", "cache", ".", "NewFilteredListWatchFromClient", "(", "client", ".", "BatchV1", "(", ")", ".", "RESTClient", "(", ")", ",", "\"", "\"", ",", "namespace", ",", "optionsModifier", ")", ",", "&", "batch_v1", ".", "Job", "{", "}", ",", "resyncPeriod", ",", "cache", ".", "Indexers", "{", "cache", ".", "NamespaceIndex", ":", "cache", ".", "MetaNamespaceIndexFunc", "}", ",", ")", "\n", "}", ")", "\n\n", "informer", ".", "AddEventHandler", "(", "cache", ".", "ResourceEventHandlerFuncs", "{", "AddFunc", ":", "func", "(", "obj", "interface", "{", "}", ")", "{", "key", ",", "err", ":=", "cache", ".", "MetaNamespaceKeyFunc", "(", "obj", ")", "\n", "if", "err", "==", "nil", "{", "queue", ".", "Add", "(", "key", ")", "\n", "}", "\n", "return", "\n", "}", ",", "UpdateFunc", ":", "func", "(", "oldObj", ",", "newObj", "interface", "{", "}", ")", "{", "key", ",", "err", ":=", "cache", ".", "MetaNamespaceKeyFunc", "(", "newObj", ")", "\n", "if", "err", "==", "nil", "{", "glog", ".", "Infof", "(", "\"", "\"", ",", "key", ")", "\n", "queue", ".", "Add", "(", "key", ")", "\n", "}", "\n", "return", "\n", "}", ",", "DeleteFunc", ":", "func", "(", "obj", "interface", "{", "}", ")", "{", "key", ",", "err", ":=", "cache", ".", "DeletionHandlingMetaNamespaceKeyFunc", "(", "obj", ")", "\n", "if", "err", "==", "nil", "{", "glog", ".", "Infof", "(", "\"", "\"", ",", "key", ")", "\n", "queue", ".", "Add", "(", "key", ")", "\n", "}", "\n", "}", ",", "}", ")", "\n\n", "return", "&", "jobController", "{", "RuntimeConfig", ":", "config", ",", "namespace", ":", "namespace", ",", "queue", ":", "queue", ",", "jobLister", ":", "batchlisters", ".", "NewJobLister", "(", "informer", ".", "GetIndexer", "(", ")", ")", ",", "}", ",", "nil", "\n\n", "}" ]

[ "NewJobController", "instantiates", "a", "new", "job", "controller", "." ]

[ "func", "(", "c", "*", "jobController", ")", "processNextItem", "(", ")", "bool", "{", "key", ",", "quit", ":=", "c", ".", "queue", ".", "Get", "(", ")", "\n", "if", "quit", "{", "return", "false", "\n", "}", "\n\n", "defer", "c", ".", "queue", ".", "Done", "(", "key", ")", "\n\n", "err", ":=", "c", ".", "processItem", "(", "key", ".", "(", "string", ")", ")", "\n", "if", "err", "==", "nil", "{", "// No error, tell the queue to stop tracking history", "c", ".", "queue", ".", "Forget", "(", "key", ")", "\n", "}", "else", "if", "c", ".", "queue", ".", "NumRequeues", "(", "key", ")", "<", "maxRetries", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "key", ",", "err", ")", "\n", "// requeue the item to work on later", "c", ".", "queue", ".", "AddRateLimited", "(", "key", ")", "\n", "}", "else", "{", "// err != nil and too many retries", "glog", ".", "Errorf", "(", "\"", "\"", ",", "key", ",", "err", ")", "\n", "c", ".", "queue", ".", "Forget", "(", "key", ")", "\n", "utilruntime", ".", "HandleError", "(", "err", ")", "\n", "}", "\n\n", "return", "true", "\n", "}" ]

[ "processNextItem", "serially", "handles", "the", "events", "provided", "by", "the", "informer", "." ]

[ "func", "(", "c", "*", "jobController", ")", "IsCleaningJobRunning", "(", "pvName", "string", ")", "bool", "{", "jobName", ":=", "generateCleaningJobName", "(", "pvName", ")", "\n", "job", ",", "err", ":=", "c", ".", "jobLister", ".", "Jobs", "(", "c", ".", "namespace", ")", ".", "Get", "(", "jobName", ")", "\n", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "false", "\n", "}", "\n\n", "if", "err", "!=", "nil", "{", "glog", ".", "Warningf", "(", "\"", "\"", ",", "jobName", ",", "err", ")", "\n", "return", "true", "\n", "}", "\n\n", "return", "job", ".", "Status", ".", "Succeeded", "<=", "0", "\n", "}" ]

[ "IsCleaningJobRunning", "returns", "true", "if", "a", "cleaning", "job", "is", "running", "for", "the", "specified", "PV", "." ]

[ "func", "(", "c", "*", "jobController", ")", "RemoveJob", "(", "pvName", "string", ")", "(", "CleanupState", ",", "*", "time", ".", "Time", ",", "error", ")", "{", "jobName", ":=", "generateCleaningJobName", "(", "pvName", ")", "\n", "job", ",", "err", ":=", "c", ".", "jobLister", ".", "Jobs", "(", "c", ".", "namespace", ")", ".", "Get", "(", "jobName", ")", "\n", "if", "err", "!=", "nil", "{", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "return", "CSNotFound", ",", "nil", ",", "nil", "\n", "}", "\n", "return", "CSUnknown", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "jobName", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "var", "startTime", "*", "time", ".", "Time", "\n", "if", "startTimeStr", ",", "ok", ":=", "job", ".", "Annotations", "[", "StartTimeAnnotation", "]", ";", "ok", "{", "parsedStartTime", ",", "err", ":=", "time", ".", "Parse", "(", "time", ".", "RFC3339Nano", ",", "startTimeStr", ")", "\n", "if", "err", "==", "nil", "{", "startTime", "=", "&", "parsedStartTime", "\n", "}", "else", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "startTimeStr", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "if", "job", ".", "Status", ".", "Succeeded", "==", "0", "{", "// Jobs has not yet succeeded. We assume failed jobs to be still running, until addressed by admin.", "return", "CSUnknown", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "job", ".", "Name", ")", "\n", "}", "\n\n", "if", "err", ":=", "c", ".", "RuntimeConfig", ".", "APIUtil", ".", "DeleteJob", "(", "job", ".", "Name", ",", "c", ".", "namespace", ")", ";", "err", "!=", "nil", "{", "return", "CSUnknown", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "job", ".", "Name", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "return", "CSSucceeded", ",", "startTime", ",", "nil", "\n", "}" ]

[ "RemoveJob", "returns", "true", "and", "deletes", "the", "job", "if", "the", "cleaning", "job", "has", "completed", "." ]

[ "func", "NewCleanupJob", "(", "pv", "*", "apiv1", ".", "PersistentVolume", ",", "volMode", "apiv1", ".", "PersistentVolumeMode", ",", "imageName", "string", ",", "nodeName", "string", ",", "namespace", "string", ",", "mountPath", "string", ",", "config", "common", ".", "MountConfig", ")", "(", "*", "batch_v1", ".", "Job", ",", "error", ")", "{", "priv", ":=", "true", "\n", "// Container definition", "jobContainer", ":=", "apiv1", ".", "Container", "{", "Name", ":", "JobContainerName", ",", "Image", ":", "imageName", ",", "SecurityContext", ":", "&", "apiv1", ".", "SecurityContext", "{", "Privileged", ":", "&", "priv", ",", "}", ",", "}", "\n", "if", "volMode", "==", "apiv1", ".", "PersistentVolumeBlock", "{", "jobContainer", ".", "Command", "=", "config", ".", "BlockCleanerCommand", "\n", "jobContainer", ".", "Env", "=", "[", "]", "apiv1", ".", "EnvVar", "{", "{", "Name", ":", "common", ".", "LocalPVEnv", ",", "Value", ":", "mountPath", "}", "}", "\n", "}", "else", "if", "volMode", "==", "apiv1", ".", "PersistentVolumeFilesystem", "{", "// We only have one way to clean filesystem, so no need to customize", "// filesystem cleaner command.", "jobContainer", ".", "Command", "=", "[", "]", "string", "{", "\"", "\"", "}", "\n", "jobContainer", ".", "Env", "=", "[", "]", "apiv1", ".", "EnvVar", "{", "{", "Name", ":", "common", ".", "LocalFilesystemEnv", ",", "Value", ":", "mountPath", "}", "}", "\n", "}", "else", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "volMode", ")", "\n", "}", "\n", "mountName", ":=", "common", ".", "GenerateMountName", "(", "&", "config", ")", "\n", "volumes", ":=", "[", "]", "apiv1", ".", "Volume", "{", "{", "Name", ":", "mountName", ",", "VolumeSource", ":", "apiv1", ".", "VolumeSource", "{", "HostPath", ":", "&", "apiv1", ".", "HostPathVolumeSource", "{", "Path", ":", "config", ".", "HostDir", ",", "}", ",", "}", ",", "}", ",", "}", "\n", "jobContainer", ".", "VolumeMounts", "=", "[", "]", "apiv1", ".", "VolumeMount", "{", "{", "Name", ":", "mountName", ",", "MountPath", ":", "config", ".", "MountDir", "}", ",", "}", "\n\n", "// Make job query-able by some useful labels for admins.", "labels", ":=", "map", "[", "string", "]", "string", "{", "common", ".", "NodeNameLabel", ":", "nodeName", ",", "PVLabel", ":", "pv", ".", "Name", ",", "PVUuidLabel", ":", "string", "(", "pv", ".", "UID", ")", ",", "}", "\n\n", "// Annotate job with useful information that cannot be set as labels due to label name restrictions.", "annotations", ":=", "map", "[", "string", "]", "string", "{", "DeviceAnnotation", ":", "mountPath", ",", "StartTimeAnnotation", ":", "time", ".", "Now", "(", ")", ".", "Format", "(", "time", ".", "RFC3339Nano", ")", ",", "}", "\n\n", "podTemplate", ":=", "apiv1", ".", "Pod", "{", "}", "\n", "podTemplate", ".", "Spec", "=", "apiv1", ".", "PodSpec", "{", "Containers", ":", "[", "]", "apiv1", ".", "Container", "{", "jobContainer", "}", ",", "Volumes", ":", "volumes", ",", "NodeSelector", ":", "map", "[", "string", "]", "string", "{", "common", ".", "NodeNameLabel", ":", "nodeName", "}", ",", "}", "\n", "podTemplate", ".", "ObjectMeta", "=", "meta_v1", ".", "ObjectMeta", "{", "Name", ":", "generateCleaningJobName", "(", "pv", ".", "Name", ")", ",", "Namespace", ":", "namespace", ",", "Labels", ":", "labels", ",", "Annotations", ":", "annotations", ",", "}", "\n", "job", ":=", "&", "batch_v1", ".", "Job", "{", "}", "\n", "job", ".", "ObjectMeta", "=", "podTemplate", ".", "ObjectMeta", "\n", "job", ".", "Spec", ".", "Template", ".", "Spec", "=", "podTemplate", ".", "Spec", "\n", "job", ".", "Spec", ".", "Template", ".", "Spec", ".", "RestartPolicy", "=", "apiv1", ".", "RestartPolicyOnFailure", "\n\n", "return", "job", ",", "nil", "\n", "}" ]

[ "NewCleanupJob", "creates", "manifest", "for", "a", "cleaning", "job", "." ]

[ "func", "(", "c", "*", "FakeJobController", ")", "IsCleaningJobRunning", "(", "pvName", "string", ")", "bool", "{", "c", ".", "IsRunningCount", "++", "\n", "_", ",", "exists", ":=", "c", ".", "pvCleanupRunning", "[", "pvName", "]", "\n", "return", "exists", "\n", "}" ]

[ "IsCleaningJobRunning", "mocks", "the", "interface", "method", "." ]

[ "func", "(", "c", "*", "FakeJobController", ")", "RemoveJob", "(", "pvName", "string", ")", "(", "CleanupState", ",", "*", "time", ".", "Time", ",", "error", ")", "{", "c", ".", "RemoveCompletedCount", "++", "\n", "status", ",", "exists", ":=", "c", ".", "pvCleanupRunning", "[", "pvName", "]", "\n", "if", "!", "exists", "{", "return", "CSNotFound", ",", "nil", ",", "nil", "\n", "}", "\n", "if", "status", "!=", "CSSucceeded", "{", "return", "CSUnknown", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "pvName", ",", "status", ")", "\n", "}", "\n", "return", "CSSucceeded", ",", "nil", ",", "nil", "\n", "}" ]

[ "RemoveJob", "mocks", "the", "interface", "method", "." ]

[ "func", "NewOpenEBSProvisioner", "(", "client", "kubernetes", ".", "Interface", ")", "controller", ".", "Provisioner", "{", "nodeName", ":=", "os", ".", "Getenv", "(", "\"", "\"", ")", "\n", "if", "nodeName", "==", "\"", "\"", "{", "glog", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "var", "openebsObj", "mApiv1", ".", "OpenEBSVolume", "\n\n", "//Get maya-apiserver IP address from cluster", "addr", ",", "err", ":=", "openebsObj", ".", "GetMayaClusterIP", "(", "client", ")", "\n\n", "if", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", "\n", "}", "\n", "mayaServiceURI", ":=", "\"", "\"", "+", "addr", "+", "\"", "\"", "\n\n", "//Set maya-apiserver IP address along with default port", "os", ".", "Setenv", "(", "\"", "\"", ",", "mayaServiceURI", ")", "\n\n", "return", "&", "openEBSProvisioner", "{", "mapiURI", ":", "mayaServiceURI", ",", "identity", ":", "nodeName", ",", "}", "\n", "}" ]

[ "NewOpenEBSProvisioner", "creates", "a", "new", "openebs", "provisioner" ]

[ "func", "(", "asw", "*", "actualStateOfWorld", ")", "AddSnapshot", "(", "snapshot", "*", "crdv1", ".", "VolumeSnapshot", ")", "error", "{", "asw", ".", "Lock", "(", ")", "\n", "defer", "asw", ".", "Unlock", "(", ")", "\n\n", "snapshotName", ":=", "MakeSnapshotName", "(", "snapshot", ")", "\n", "glog", ".", "Infof", "(", "\"", "\"", ",", "snapshotName", ")", "\n", "asw", ".", "snapshots", "[", "snapshotName", "]", "=", "snapshot", "\n", "return", "nil", "\n", "}" ]

[ "Adds", "a", "snapshot", "to", "the", "list", "of", "snapshots", "to", "be", "created", "." ]

[ "func", "(", "asw", "*", "actualStateOfWorld", ")", "DeleteSnapshot", "(", "snapshotName", "string", ")", "error", "{", "asw", ".", "Lock", "(", ")", "\n", "defer", "asw", ".", "Unlock", "(", ")", "\n\n", "glog", ".", "Infof", "(", "\"", "\"", ",", "snapshotName", ")", "\n", "delete", "(", "asw", ".", "snapshots", ",", "snapshotName", ")", "\n", "return", "nil", "\n", "}" ]

[ "Removes", "the", "snapshot", "from", "the", "list", "of", "existing", "snapshots", "." ]

[ "func", "Each", "(", "array", "[", "]", "interface", "{", "}", ",", "iterator", "Iterator", ")", "{", "for", "index", ",", "data", ":=", "range", "array", "{", "iterator", "(", "data", ",", "index", ")", "\n", "}", "\n", "}" ]

[ "Each", "iterates", "over", "the", "slice", "and", "apply", "Iterator", "to", "every", "item" ]

[ "func", "Map", "(", "array", "[", "]", "interface", "{", "}", ",", "iterator", "ResultIterator", ")", "[", "]", "interface", "{", "}", "{", "var", "result", "=", "make", "(", "[", "]", "interface", "{", "}", ",", "len", "(", "array", ")", ")", "\n", "for", "index", ",", "data", ":=", "range", "array", "{", "result", "[", "index", "]", "=", "iterator", "(", "data", ",", "index", ")", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "Map", "iterates", "over", "the", "slice", "and", "apply", "ResultIterator", "to", "every", "item", ".", "Returns", "new", "slice", "as", "a", "result", "." ]

[ "func", "Find", "(", "array", "[", "]", "interface", "{", "}", ",", "iterator", "ConditionIterator", ")", "interface", "{", "}", "{", "for", "index", ",", "data", ":=", "range", "array", "{", "if", "iterator", "(", "data", ",", "index", ")", "{", "return", "data", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Find", "iterates", "over", "the", "slice", "and", "apply", "ConditionIterator", "to", "every", "item", ".", "Returns", "first", "item", "that", "meet", "ConditionIterator", "or", "nil", "otherwise", "." ]

[ "func", "Filter", "(", "array", "[", "]", "interface", "{", "}", ",", "iterator", "ConditionIterator", ")", "[", "]", "interface", "{", "}", "{", "var", "result", "=", "make", "(", "[", "]", "interface", "{", "}", ",", "0", ")", "\n", "for", "index", ",", "data", ":=", "range", "array", "{", "if", "iterator", "(", "data", ",", "index", ")", "{", "result", "=", "append", "(", "result", ",", "data", ")", "\n", "}", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "Filter", "iterates", "over", "the", "slice", "and", "apply", "ConditionIterator", "to", "every", "item", ".", "Returns", "new", "slice", "." ]

[ "func", "Count", "(", "array", "[", "]", "interface", "{", "}", ",", "iterator", "ConditionIterator", ")", "int", "{", "count", ":=", "0", "\n", "for", "index", ",", "data", ":=", "range", "array", "{", "if", "iterator", "(", "data", ",", "index", ")", "{", "count", "=", "count", "+", "1", "\n", "}", "\n", "}", "\n", "return", "count", "\n", "}" ]

[ "Count", "iterates", "over", "the", "slice", "and", "apply", "ConditionIterator", "to", "every", "item", ".", "Returns", "count", "of", "items", "that", "meets", "ConditionIterator", "." ]

[ "func", "LeftTrim", "(", "str", ",", "chars", "string", ")", "string", "{", "if", "chars", "==", "\"", "\"", "{", "return", "strings", ".", "TrimLeftFunc", "(", "str", ",", "unicode", ".", "IsSpace", ")", "\n", "}", "\n", "r", ",", "_", ":=", "regexp", ".", "Compile", "(", "\"", "\"", "+", "chars", "+", "\"", "\"", ")", "\n", "return", "r", ".", "ReplaceAllString", "(", "str", ",", "\"", "\"", ")", "\n", "}" ]

[ "LeftTrim", "trim", "characters", "from", "the", "left", "-", "side", "of", "the", "input", ".", "If", "second", "argument", "is", "empty", "it", "s", "will", "be", "remove", "leading", "spaces", "." ]

[ "func", "RightTrim", "(", "str", ",", "chars", "string", ")", "string", "{", "if", "chars", "==", "\"", "\"", "{", "return", "strings", ".", "TrimRightFunc", "(", "str", ",", "unicode", ".", "IsSpace", ")", "\n", "}", "\n", "r", ",", "_", ":=", "regexp", ".", "Compile", "(", "\"", "\"", "+", "chars", "+", "\"", "\"", ")", "\n", "return", "r", ".", "ReplaceAllString", "(", "str", ",", "\"", "\"", ")", "\n", "}" ]

[ "RightTrim", "trim", "characters", "from", "the", "right", "-", "side", "of", "the", "input", ".", "If", "second", "argument", "is", "empty", "it", "s", "will", "be", "remove", "spaces", "." ]

[ "func", "Trim", "(", "str", ",", "chars", "string", ")", "string", "{", "return", "LeftTrim", "(", "RightTrim", "(", "str", ",", "chars", ")", ",", "chars", ")", "\n", "}" ]

[ "Trim", "trim", "characters", "from", "both", "sides", "of", "the", "input", ".", "If", "second", "argument", "is", "empty", "it", "s", "will", "be", "remove", "spaces", "." ]

[ "func", "WhiteList", "(", "str", ",", "chars", "string", ")", "string", "{", "pattern", ":=", "\"", "\"", "+", "chars", "+", "\"", "\"", "\n", "r", ",", "_", ":=", "regexp", ".", "Compile", "(", "pattern", ")", "\n", "return", "r", ".", "ReplaceAllString", "(", "str", ",", "\"", "\"", ")", "\n", "}" ]

[ "WhiteList", "remove", "characters", "that", "do", "not", "appear", "in", "the", "whitelist", "." ]

[ "func", "ReplacePattern", "(", "str", ",", "pattern", ",", "replace", "string", ")", "string", "{", "r", ",", "_", ":=", "regexp", ".", "Compile", "(", "pattern", ")", "\n", "return", "r", ".", "ReplaceAllString", "(", "str", ",", "replace", ")", "\n", "}" ]

[ "ReplacePattern", "replace", "regular", "expression", "pattern", "in", "string" ]

[ "func", "Reverse", "(", "s", "string", ")", "string", "{", "r", ":=", "[", "]", "rune", "(", "s", ")", "\n", "for", "i", ",", "j", ":=", "0", ",", "len", "(", "r", ")", "-", "1", ";", "i", "<", "j", ";", "i", ",", "j", "=", "i", "+", "1", ",", "j", "-", "1", "{", "r", "[", "i", "]", ",", "r", "[", "j", "]", "=", "r", "[", "j", "]", ",", "r", "[", "i", "]", "\n", "}", "\n", "return", "string", "(", "r", ")", "\n", "}" ]

[ "Reverse", "return", "reversed", "string" ]

[ "func", "GetLine", "(", "s", "string", ",", "index", "int", ")", "(", "string", ",", "error", ")", "{", "lines", ":=", "GetLines", "(", "s", ")", "\n", "if", "index", "<", "0", "||", "index", ">=", "len", "(", "lines", ")", "{", "return", "\"", "\"", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "lines", "[", "index", "]", ",", "nil", "\n", "}" ]

[ "GetLine", "return", "specified", "line", "of", "multiline", "string" ]

[ "func", "SafeFileName", "(", "str", "string", ")", "string", "{", "name", ":=", "strings", ".", "ToLower", "(", "str", ")", "\n", "name", "=", "path", ".", "Clean", "(", "path", ".", "Base", "(", "name", ")", ")", "\n", "name", "=", "strings", ".", "Trim", "(", "name", ",", "\"", "\"", ")", "\n", "separators", ",", "err", ":=", "regexp", ".", "Compile", "(", "`[ &_=+:]`", ")", "\n", "if", "err", "==", "nil", "{", "name", "=", "separators", ".", "ReplaceAllString", "(", "name", ",", "\"", "\"", ")", "\n", "}", "\n", "legal", ",", "err", ":=", "regexp", ".", "Compile", "(", "`[^[:alnum:]-.]`", ")", "\n", "if", "err", "==", "nil", "{", "name", "=", "legal", ".", "ReplaceAllString", "(", "name", ",", "\"", "\"", ")", "\n", "}", "\n", "for", "strings", ".", "Contains", "(", "name", ",", "\"", "\"", ")", "{", "name", "=", "strings", ".", "Replace", "(", "name", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n", "}", "\n", "return", "name", "\n", "}" ]

[ "SafeFileName", "return", "safe", "string", "that", "can", "be", "used", "in", "file", "names" ]

[ "func", "Truncate", "(", "str", "string", ",", "length", "int", ",", "ending", "string", ")", "string", "{", "var", "aftstr", ",", "befstr", "string", "\n", "if", "len", "(", "str", ")", ">", "length", "{", "words", ":=", "strings", ".", "Fields", "(", "str", ")", "\n", "before", ",", "present", ":=", "0", ",", "0", "\n", "for", "i", ":=", "range", "words", "{", "befstr", "=", "aftstr", "\n", "before", "=", "present", "\n", "aftstr", "=", "aftstr", "+", "words", "[", "i", "]", "+", "\"", "\"", "\n", "present", "=", "len", "(", "aftstr", ")", "\n", "if", "present", ">", "length", "&&", "i", "!=", "0", "{", "if", "(", "length", "-", "before", ")", "<", "(", "present", "-", "length", ")", "{", "return", "Trim", "(", "befstr", ",", "\"", "\\\\", "\\\"", "\"", ")", "+", "ending", "\n", "}", "\n", "return", "Trim", "(", "aftstr", ",", "\"", "\\\\", "\\\"", "\"", ")", "+", "ending", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "str", "\n", "}" ]

[ "Truncate", "a", "string", "to", "the", "closest", "length", "without", "breaking", "words", "." ]

[ "func", "PadLeft", "(", "str", "string", ",", "padStr", "string", ",", "padLen", "int", ")", "string", "{", "return", "buildPadStr", "(", "str", ",", "padStr", ",", "padLen", ",", "true", ",", "false", ")", "\n", "}" ]

[ "PadLeft", "pad", "left", "side", "of", "string", "if", "size", "of", "string", "is", "less", "then", "indicated", "pad", "length" ]

[ "func", "PadBoth", "(", "str", "string", ",", "padStr", "string", ",", "padLen", "int", ")", "string", "{", "return", "buildPadStr", "(", "str", ",", "padStr", ",", "padLen", ",", "true", ",", "true", ")", "\n", "}" ]

[ "PadBoth", "pad", "sides", "of", "string", "if", "size", "of", "string", "is", "less", "then", "indicated", "pad", "length" ]

[ "func", "buildPadStr", "(", "str", "string", ",", "padStr", "string", ",", "padLen", "int", ",", "padLeft", "bool", ",", "padRight", "bool", ")", "string", "{", "// When padded length is less then the current string size", "if", "padLen", "<", "utf8", ".", "RuneCountInString", "(", "str", ")", "{", "return", "str", "\n", "}", "\n\n", "padLen", "-=", "utf8", ".", "RuneCountInString", "(", "str", ")", "\n\n", "targetLen", ":=", "padLen", "\n\n", "targetLenLeft", ":=", "targetLen", "\n", "targetLenRight", ":=", "targetLen", "\n", "if", "padLeft", "&&", "padRight", "{", "targetLenLeft", "=", "padLen", "/", "2", "\n", "targetLenRight", "=", "padLen", "-", "targetLenLeft", "\n", "}", "\n\n", "strToRepeatLen", ":=", "utf8", ".", "RuneCountInString", "(", "padStr", ")", "\n\n", "repeatTimes", ":=", "int", "(", "math", ".", "Ceil", "(", "float64", "(", "targetLen", ")", "/", "float64", "(", "strToRepeatLen", ")", ")", ")", "\n", "repeatedString", ":=", "strings", ".", "Repeat", "(", "padStr", ",", "repeatTimes", ")", "\n\n", "leftSide", ":=", "\"", "\"", "\n", "if", "padLeft", "{", "leftSide", "=", "repeatedString", "[", "0", ":", "targetLenLeft", "]", "\n", "}", "\n\n", "rightSide", ":=", "\"", "\"", "\n", "if", "padRight", "{", "rightSide", "=", "repeatedString", "[", "0", ":", "targetLenRight", "]", "\n", "}", "\n\n", "return", "leftSide", "+", "str", "+", "rightSide", "\n", "}" ]

[ "PadString", "either", "left", "right", "or", "both", "sides", "not", "the", "padding", "string", "can", "be", "unicode", "and", "more", "then", "one", "character" ]

[ "func", "TruncatingErrorf", "(", "str", "string", ",", "args", "...", "interface", "{", "}", ")", "error", "{", "n", ":=", "strings", ".", "Count", "(", "str", ",", "\"", "\"", ")", "\n", "return", "fmt", ".", "Errorf", "(", "str", ",", "args", "[", ":", "n", "]", "...", ")", "\n", "}" ]

[ "TruncatingErrorf", "removes", "extra", "args", "from", "fmt", ".", "Errorf", "if", "not", "formatted", "in", "the", "str", "object" ]

[ "func", "ToJSON", "(", "obj", "interface", "{", "}", ")", "(", "string", ",", "error", ")", "{", "res", ",", "err", ":=", "json", ".", "Marshal", "(", "obj", ")", "\n", "if", "err", "!=", "nil", "{", "res", "=", "[", "]", "byte", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "string", "(", "res", ")", ",", "err", "\n", "}" ]

[ "ToJSON", "convert", "the", "input", "to", "a", "valid", "JSON", "string" ]

[ "func", "ToFloat", "(", "str", "string", ")", "(", "float64", ",", "error", ")", "{", "res", ",", "err", ":=", "strconv", ".", "ParseFloat", "(", "str", ",", "64", ")", "\n", "if", "err", "!=", "nil", "{", "res", "=", "0.0", "\n", "}", "\n", "return", "res", ",", "err", "\n", "}" ]

[ "ToFloat", "convert", "the", "input", "string", "to", "a", "float", "or", "0", ".", "0", "if", "the", "input", "is", "not", "a", "float", "." ]

[ "func", "ToInt", "(", "value", "interface", "{", "}", ")", "(", "res", "int64", ",", "err", "error", ")", "{", "val", ":=", "reflect", ".", "ValueOf", "(", "value", ")", "\n\n", "switch", "value", ".", "(", "type", ")", "{", "case", "int", ",", "int8", ",", "int16", ",", "int32", ",", "int64", ":", "res", "=", "val", ".", "Int", "(", ")", "\n", "case", "uint", ",", "uint8", ",", "uint16", ",", "uint32", ",", "uint64", ":", "res", "=", "int64", "(", "val", ".", "Uint", "(", ")", ")", "\n", "case", "string", ":", "if", "IsInt", "(", "val", ".", "String", "(", ")", ")", "{", "res", ",", "err", "=", "strconv", ".", "ParseInt", "(", "val", ".", "String", "(", ")", ",", "0", ",", "64", ")", "\n", "if", "err", "!=", "nil", "{", "res", "=", "0", "\n", "}", "\n", "}", "else", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "value", ")", "\n", "res", "=", "0", "\n", "}", "\n", "default", ":", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "value", ")", "\n", "res", "=", "0", "\n", "}", "\n\n", "return", "\n", "}" ]

[ "ToInt", "convert", "the", "input", "string", "or", "any", "int", "type", "to", "an", "integer", "type", "64", "or", "0", "if", "the", "input", "is", "not", "an", "integer", "." ]

[ "func", "InRange", "(", "value", "interface", "{", "}", ",", "left", "interface", "{", "}", ",", "right", "interface", "{", "}", ")", "bool", "{", "reflectValue", ":=", "reflect", ".", "TypeOf", "(", "value", ")", ".", "Kind", "(", ")", "\n", "reflectLeft", ":=", "reflect", ".", "TypeOf", "(", "left", ")", ".", "Kind", "(", ")", "\n", "reflectRight", ":=", "reflect", ".", "TypeOf", "(", "right", ")", ".", "Kind", "(", ")", "\n\n", "if", "reflectValue", "==", "reflect", ".", "Int", "&&", "reflectLeft", "==", "reflect", ".", "Int", "&&", "reflectRight", "==", "reflect", ".", "Int", "{", "return", "InRangeInt", "(", "value", ".", "(", "int", ")", ",", "left", ".", "(", "int", ")", ",", "right", ".", "(", "int", ")", ")", "\n", "}", "else", "if", "reflectValue", "==", "reflect", ".", "Float32", "&&", "reflectLeft", "==", "reflect", ".", "Float32", "&&", "reflectRight", "==", "reflect", ".", "Float32", "{", "return", "InRangeFloat32", "(", "value", ".", "(", "float32", ")", ",", "left", ".", "(", "float32", ")", ",", "right", ".", "(", "float32", ")", ")", "\n", "}", "else", "if", "reflectValue", "==", "reflect", ".", "Float64", "&&", "reflectLeft", "==", "reflect", ".", "Float64", "&&", "reflectRight", "==", "reflect", ".", "Float64", "{", "return", "InRangeFloat64", "(", "value", ".", "(", "float64", ")", ",", "left", ".", "(", "float64", ")", ",", "right", ".", "(", "float64", ")", ")", "\n", "}", "else", "{", "return", "false", "\n", "}", "\n", "}" ]

[ "InRange", "returns", "true", "if", "value", "lies", "between", "left", "and", "right", "border", "generic", "type", "to", "handle", "int", "float32", "or", "float64", "all", "types", "must", "the", "same", "type" ]

[ "func", "IsExistingEmail", "(", "email", "string", ")", "bool", "{", "if", "len", "(", "email", ")", "<", "6", "||", "len", "(", "email", ")", ">", "254", "{", "return", "false", "\n", "}", "\n", "at", ":=", "strings", ".", "LastIndex", "(", "email", ",", "\"", "\"", ")", "\n", "if", "at", "<=", "0", "||", "at", ">", "len", "(", "email", ")", "-", "3", "{", "return", "false", "\n", "}", "\n", "user", ":=", "email", "[", ":", "at", "]", "\n", "host", ":=", "email", "[", "at", "+", "1", ":", "]", "\n", "if", "len", "(", "user", ")", ">", "64", "{", "return", "false", "\n", "}", "\n", "if", "userDotRegexp", ".", "MatchString", "(", "user", ")", "||", "!", "userRegexp", ".", "MatchString", "(", "user", ")", "||", "!", "hostRegexp", ".", "MatchString", "(", "host", ")", "{", "return", "false", "\n", "}", "\n", "switch", "host", "{", "case", "\"", "\"", ",", "\"", "\"", ":", "return", "true", "\n", "}", "\n", "if", "_", ",", "err", ":=", "net", ".", "LookupMX", "(", "host", ")", ";", "err", "!=", "nil", "{", "if", "_", ",", "err", ":=", "net", ".", "LookupIP", "(", "host", ")", ";", "err", "!=", "nil", "{", "return", "false", "\n", "}", "\n", "}", "\n\n", "return", "true", "\n", "}" ]

[ "IsExistingEmail", "check", "if", "the", "string", "is", "an", "email", "of", "existing", "domain" ]

[ "func", "IsRequestURL", "(", "rawurl", "string", ")", "bool", "{", "url", ",", "err", ":=", "url", ".", "ParseRequestURI", "(", "rawurl", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", "//Couldn't even parse the rawurl", "\n", "}", "\n", "if", "len", "(", "url", ".", "Scheme", ")", "==", "0", "{", "return", "false", "//No Scheme found", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "IsRequestURL", "check", "if", "the", "string", "rawurl", "assuming", "it", "was", "received", "in", "an", "HTTP", "request", "is", "a", "valid", "URL", "confirm", "to", "RFC", "3986" ]

[ "func", "IsRequestURI", "(", "rawurl", "string", ")", "bool", "{", "_", ",", "err", ":=", "url", ".", "ParseRequestURI", "(", "rawurl", ")", "\n", "return", "err", "==", "nil", "\n", "}" ]

[ "IsRequestURI", "check", "if", "the", "string", "rawurl", "assuming", "it", "was", "received", "in", "an", "HTTP", "request", "is", "an", "absolute", "URI", "or", "an", "absolute", "path", "." ]

[ "func", "IsLowerCase", "(", "str", "string", ")", "bool", "{", "if", "IsNull", "(", "str", ")", "{", "return", "true", "\n", "}", "\n", "return", "str", "==", "strings", ".", "ToLower", "(", "str", ")", "\n", "}" ]

[ "IsLowerCase", "check", "if", "the", "string", "is", "lowercase", ".", "Empty", "string", "is", "valid", "." ]

[ "func", "IsUpperCase", "(", "str", "string", ")", "bool", "{", "if", "IsNull", "(", "str", ")", "{", "return", "true", "\n", "}", "\n", "return", "str", "==", "strings", ".", "ToUpper", "(", "str", ")", "\n", "}" ]

[ "IsUpperCase", "check", "if", "the", "string", "is", "uppercase", ".", "Empty", "string", "is", "valid", "." ]

[ "func", "HasLowerCase", "(", "str", "string", ")", "bool", "{", "if", "IsNull", "(", "str", ")", "{", "return", "true", "\n", "}", "\n", "return", "rxHasLowerCase", ".", "MatchString", "(", "str", ")", "\n", "}" ]

[ "HasLowerCase", "check", "if", "the", "string", "contains", "at", "least", "1", "lowercase", ".", "Empty", "string", "is", "valid", "." ]

[ "func", "HasUpperCase", "(", "str", "string", ")", "bool", "{", "if", "IsNull", "(", "str", ")", "{", "return", "true", "\n", "}", "\n", "return", "rxHasUpperCase", ".", "MatchString", "(", "str", ")", "\n", "}" ]

[ "HasUpperCase", "check", "if", "the", "string", "contians", "as", "least", "1", "uppercase", ".", "Empty", "string", "is", "valid", "." ]

[ "func", "IsInt", "(", "str", "string", ")", "bool", "{", "if", "IsNull", "(", "str", ")", "{", "return", "true", "\n", "}", "\n", "return", "rxInt", ".", "MatchString", "(", "str", ")", "\n", "}" ]

[ "IsInt", "check", "if", "the", "string", "is", "an", "integer", ".", "Empty", "string", "is", "valid", "." ]

[ "func", "IsFullWidth", "(", "str", "string", ")", "bool", "{", "if", "IsNull", "(", "str", ")", "{", "return", "true", "\n", "}", "\n", "return", "rxFullWidth", ".", "MatchString", "(", "str", ")", "\n", "}" ]

[ "IsFullWidth", "check", "if", "the", "string", "contains", "any", "full", "-", "width", "chars", ".", "Empty", "string", "is", "valid", "." ]

[ "func", "IsHalfWidth", "(", "str", "string", ")", "bool", "{", "if", "IsNull", "(", "str", ")", "{", "return", "true", "\n", "}", "\n", "return", "rxHalfWidth", ".", "MatchString", "(", "str", ")", "\n", "}" ]

[ "IsHalfWidth", "check", "if", "the", "string", "contains", "any", "half", "-", "width", "chars", ".", "Empty", "string", "is", "valid", "." ]

[ "func", "IsVariableWidth", "(", "str", "string", ")", "bool", "{", "if", "IsNull", "(", "str", ")", "{", "return", "true", "\n", "}", "\n", "return", "rxHalfWidth", ".", "MatchString", "(", "str", ")", "&&", "rxFullWidth", ".", "MatchString", "(", "str", ")", "\n", "}" ]

[ "IsVariableWidth", "check", "if", "the", "string", "contains", "a", "mixture", "of", "full", "and", "half", "-", "width", "chars", ".", "Empty", "string", "is", "valid", "." ]

[ "func", "IsFilePath", "(", "str", "string", ")", "(", "bool", ",", "int", ")", "{", "if", "rxWinPath", ".", "MatchString", "(", "str", ")", "{", "//check windows path limit see:", "// http://msdn.microsoft.com/en-us/library/aa365247(VS.85).aspx#maxpath", "if", "len", "(", "str", "[", "3", ":", "]", ")", ">", "32767", "{", "return", "false", ",", "Win", "\n", "}", "\n", "return", "true", ",", "Win", "\n", "}", "else", "if", "rxUnixPath", ".", "MatchString", "(", "str", ")", "{", "return", "true", ",", "Unix", "\n", "}", "\n", "return", "false", ",", "Unknown", "\n", "}" ]

[ "IsFilePath", "check", "is", "a", "string", "is", "Win", "or", "Unix", "file", "path", "and", "returns", "it", "s", "type", "." ]