Add support for custom path patterns

README.md

@@ -270,8 +270,9 @@ A few things to note; the annotation for the `StorageClass` will apply to all vo
 
 ### Storage classes
 
-If more than one `paths` are specified in the `nodePathMap` the path is chosen randomly. To make the provisioner choose a specific path, use a `storageClass` defined with a parameter called `nodePath`. Note that this path should be defined in the `nodePathMap`
+If more than one `paths` are specified in the `nodePathMap` the path is chosen randomly. To make the provisioner choose a specific path, use a `storageClass` defined with a parameter called `nodePath`. Note that this path should be defined in the `nodePathMap`.
 
+By default the volume subdirectory is named using the template `{{ .PVName }}_{{ .PVC.Namespace }}_{{ .PVC.Name }}` which make the directory specific to the PV instance. The template can be changed using the `pathPattern` parameter which is interpreted as a go template. The template has access to the PV name using the `PVName` variable and the PVC metadata object, including labels and annotations, with the `PVC` variable.
 ```
 apiVersion: storage.k8s.io/v1
 kind: StorageClass
@@ -280,11 +281,12 @@ metadata:
 provisioner: rancher.io/local-path
 parameters:
   nodePath: /data/ssd
+  pathPattern: "{{ .PVC.Namespace }}/{{ .PVC.Name }}"
 volumeBindingMode: WaitForFirstConsumer
 reclaimPolicy: Delete
 ```
 
-Here the provisioner will use the path `/data/ssd` when storage class `ssd-local-path` is used.
+Here the provisioner will use the path `/data/ssd` with a subdirectory per namespace and PVC when storage class `ssd-local-path` is used.
 
 ## Uninstall
 

deploy/chart/local-path-provisioner/README.md

@@ -65,6 +65,7 @@ default values.
 | `storageClass.defaultVolumeType`    | The default volume type this storage class creates                              | `hostPath`                                                                          |
 | `storageClass.name`                 | The name to assign the created StorageClass                                     | local-path                                                                          |
 | `storageClass.reclaimPolicy`        | ReclaimPolicy field of the class                                                | Delete                                                                              |
+| `storageClass.pathPattern`          | Template for the volume directory name                                          | `nil`                                                                               |
 | `nodePathMap`                       | Configuration of where to store the data on each node                           | `[{node: DEFAULT_PATH_FOR_NON_LISTED_NODES, paths: [/opt/local-path-provisioner]}]` |
 | `resources`                         | Local Path Provisioner resource requests & limits                               | `{}`                                                                                |
 | `rbac.create`                       | If true, create & use RBAC resources                                            | `true`                                                                              |

deploy/chart/local-path-provisioner/templates/storageclass.yaml

@@ -20,6 +20,10 @@ provisioner: {{ template "local-path-provisioner.provisionerName" $dot }}
 volumeBindingMode: {{ $values.storageClass.volumeBindingMode }}
 reclaimPolicy: {{ $values.storageClass.reclaimPolicy }}
 allowVolumeExpansion: true
+{{- if .Values.storageClass.pathPattern }}
+parameters:
+  pathPattern: {{ .Values.storageClass.pathPattern | quote }}
+{{  end -}}
 {{- end }}
 ---
 {{- end }}

deploy/chart/local-path-provisioner/values.yaml

@@ -48,6 +48,9 @@ storageClass:
   ## volumeBindingMode field controls when volume binding and dynamic provisioning should occur, can be  "Immediate" or "WaitForFirstConsumer"
   volumeBindingMode: WaitForFirstConsumer
 
+  ## Set a path pattern, if unset the default will be used
+  # pathPattern: "{{ .PVC.Namespace }}-{{ .PVC.Name }}"
+
 # nodePathMap is the place user can customize where to store the data on each node.
 # 1. If one node is not listed on the nodePathMap, and Kubernetes wants to create volume on it, the paths specified in
 #    DEFAULT_PATH_FOR_NON_LISTED_NODES will be used for provisioning.

provisioner.go

@@ -12,6 +12,7 @@ import (
 	"strconv"
 	"strings"
 	"sync"
+	"text/template"
 	"time"
 
 	"github.com/Sirupsen/logrus"
@@ -265,6 +266,31 @@ func (p *LocalPathProvisioner) pickConfig(storageClassName string) (*StorageClas
 	return &cfg, nil
 }
 
+type pvMetadata struct {
+	PVName string
+	PVC    metav1.ObjectMeta
+}
+
+func pathFromPattern(pattern string, opts pvController.ProvisionOptions) (string, error) {
+	metadata := pvMetadata{
+		PVName: opts.PVName,
+		PVC: opts.PVC.ObjectMeta,
+	}
+
+	tpl, err := template.New("pathPattern").Parse(pattern)
+	if err != nil {
+		return "", err
+	}
+
+	buf := new(bytes.Buffer)
+	err = tpl.Execute(buf, metadata)
+	if err != nil {
+		return "", err
+	}
+
+	return buf.String(), nil
+}
+
 func (p *LocalPathProvisioner) Provision(ctx context.Context, opts pvController.ProvisionOptions) (*v1.PersistentVolume, pvController.ProvisioningState, error) {
 	cfg, err := p.pickConfig(opts.StorageClass.Name)
 	if err != nil {
@@ -314,6 +340,15 @@ func (p *LocalPathProvisioner) provisionFor(opts pvController.ProvisionOptions,
 	name := opts.PVName
 	folderName := strings.Join([]string{name, opts.PVC.Namespace, opts.PVC.Name}, "_")
 
+	pathPattern, exists := opts.StorageClass.Parameters["pathPattern"]
+	if exists {
+		folderName, err = pathFromPattern(pathPattern, opts)
+		if err != nil {
+			err = errors.Wrapf(err, "failed to create path from pattern %v", pathPattern)
+			return nil, pvController.ProvisioningFinished, err
+		}
+	}
+
 	path := filepath.Join(basePath, folderName)
 	if nodeName == "" {
 		logrus.Infof("Creating volume %v at %v", name, path)