nextflow.k8s.model.PodVolumeClaim.groovy Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of nextflow Show documentation

A DSL modelled around the UNIX pipe concept, that simplifies writing parallel and scalable pipelines in a portable manner

There is a newer version: 24.11.0-edge

Show newest version

/*
 * Copyright 2013-2024, Seqera Labs
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package nextflow.k8s.model

import groovy.transform.CompileStatic
import groovy.transform.EqualsAndHashCode
import groovy.transform.ToString

/**
 * Model a K8s pod persistent volume claim mount
 *
 * See https://kubernetes.io/docs/tasks/configure-pod-container/configure-persistent-volume-storage/#create-a-persistentvolumeclaim
 *
 * @author Paolo Di Tommaso 
 */
@CompileStatic
@ToString(includeNames = true)
@EqualsAndHashCode
class PodVolumeClaim {

    String claimName

    String mountPath

    String subPath

    boolean readOnly

    PodVolumeClaim(String name, String mount, String subPath=null, boolean readOnly=false) {
        assert name
        assert mount
        this.claimName = name
        this.mountPath = sanitize(mount)
        this.subPath = subPath
        this.readOnly = readOnly
        validate(mountPath)
    }

    PodVolumeClaim(Map entry) {
        assert entry.volumeClaim
        assert entry.mountPath
        this.claimName = entry.volumeClaim
        this.mountPath = sanitize(entry.mountPath)
        this.subPath = entry.subPath
        this.readOnly = entry.readOnly ?: false
        validate(mountPath)
    }

    private static validate(String path) {
        if( !path.startsWith('/') )
            throw new IllegalArgumentException("K8s volume claim path must be an absolute path: $path")
    }

    static private String sanitize(path) {
        if( !path ) return null
        def result = path.toString().trim()
        while( result.endsWith('/') && result.size()>1 )
            result = result.substring(0,result.size()-1)
        return result
    }

}