Storage.java

// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you 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 com.cloud.storage;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;

import org.apache.commons.lang.NotImplementedException;
import org.apache.commons.lang3.StringUtils;

public class Storage {
    public static enum ImageFormat {
        QCOW2(true, true, false, "qcow2"),
        RAW(false, false, false, "raw"),
        VHD(true, true, true, "vhd"),
        ISO(false, false, false, "iso"),
        OVA(true, true, true, "ova"),
        VHDX(true, true, true, "vhdx"),
        BAREMETAL(false, false, false, "BAREMETAL"),
        VMDK(true, true, false, "vmdk"),
        VDI(true, true, false, "vdi"),
        TAR(false, false, false, "tar"),
        ZIP(false, false, false, "zip"),
        DIR(false, false, false, "dir");

        private final boolean supportThinProvisioning;
        private final boolean supportSparse;
        private final boolean supportSnapshot;
        private final String fileExtension;

        private ImageFormat(boolean supportThinProvisioning, boolean supportSparse, boolean supportSnapshot) {
            this.supportThinProvisioning = supportThinProvisioning;
            this.supportSparse = supportSparse;
            this.supportSnapshot = supportSnapshot;
            fileExtension = null;
        }

        private ImageFormat(boolean supportThinProvisioning, boolean supportSparse, boolean supportSnapshot, String fileExtension) {
            this.supportThinProvisioning = supportThinProvisioning;
            this.supportSparse = supportSparse;
            this.supportSnapshot = supportSnapshot;
            this.fileExtension = fileExtension;
        }

        public boolean supportThinProvisioning() {
            return supportThinProvisioning;
        }

        public boolean supportsSparse() {
            return supportSparse;
        }

        public boolean supportSnapshot() {
            return supportSnapshot;
        }

        public String getFileExtension() {
            if (fileExtension == null)
                return toString().toLowerCase();

            return fileExtension;
        }

    }

    public static enum Capability {
        HARDWARE_ACCELERATION("HARDWARE_ACCELERATION"),
        ALLOW_MIGRATE_OTHER_POOLS("ALLOW_MIGRATE_OTHER_POOLS");

        private final String capability;

        private Capability(String capability) {
            this.capability = capability;
        }

        public String toString() {
            return this.capability;
        }
    }

    public static enum ProvisioningType {
        THIN("thin"),
        SPARSE("sparse"),
        FAT("fat");

        private final String provisionType;

        private ProvisioningType(String provisionType){
            this.provisionType = provisionType;
        }

        public String toString(){
            return this.provisionType;
        }

        public static ProvisioningType getProvisioningType(String provisioningType){

            if(provisioningType.equals(THIN.provisionType)){
                return ProvisioningType.THIN;
            } else if(provisioningType.equals(SPARSE.provisionType)){
                return ProvisioningType.SPARSE;
            } else if (provisioningType.equals(FAT.provisionType)){
                return ProvisioningType.FAT;
            } else{
                    throw new NotImplementedException();
            }
        }
    }

    public static enum FileSystem {
        Unknown, ext3, ntfs, fat, fat32, ext2, ext4, cdfs, hpfs, ufs, hfs, hfsp
    }

    public static enum TemplateType {
        ROUTING, // Router template
        SYSTEM, /* routing, system vm template */
        BUILTIN, /* buildin template */
        PERHOST, /* every host has this template, don't need to install it in secondary storage */
        USER, /* User supplied template/iso */
        VNF,    /* VNFs (virtual network functions) template */
        DATADISK, /* Template corresponding to a datadisk(non root disk) present in an OVA */
        ISODISK /* Template corresponding to a iso (non root disk) present in an OVA */
    }

    /**
     * StoragePoolTypes carry some details about the format and capabilities of a storage pool. While not necessarily a
     * 1:1 with PrimaryDataStoreDriver (and for KVM agent, KVMStoragePool and StorageAdaptor) implementations, it is
     * often used to decide which storage plugin or storage command to call, so it may be necessary for new storage
     * plugins to add a StoragePoolType.  This can be done by adding it below, or by creating a new public static final
     * instance of StoragePoolType in the plugin itself, which registers it with the map.
     *
     * Note that if the StoragePoolType is for KVM and defined in plugin code rather than below, care must be taken to
     * ensure this is available on the agent side as well. This is best done by defining the StoragePoolType in a common
     * package available on both management server and agent plugin jars.
     */
    public static class StoragePoolType {
        private static final Map<String, StoragePoolType> map = new LinkedHashMap<>();

        public static final StoragePoolType Filesystem = new StoragePoolType("Filesystem", false, true, true);
        public static final StoragePoolType NetworkFilesystem = new StoragePoolType("NetworkFilesystem", true, true, true);
        public static final StoragePoolType IscsiLUN = new StoragePoolType("IscsiLUN", true, false, false);
        public static final StoragePoolType Iscsi = new StoragePoolType("Iscsi", true, false, false);
        public static final StoragePoolType ISO = new StoragePoolType("ISO", false, false, false);
        public static final StoragePoolType LVM = new StoragePoolType("LVM", false, false, false);
        public static final StoragePoolType CLVM = new StoragePoolType("CLVM", true, false, false);
        public static final StoragePoolType RBD = new StoragePoolType("RBD", true, true, false);
        public static final StoragePoolType SharedMountPoint = new StoragePoolType("SharedMountPoint", true, false, true);
        public static final StoragePoolType VMFS = new StoragePoolType("VMFS", true, true, false);
        public static final StoragePoolType PreSetup = new StoragePoolType("PreSetup", true, true, false);
        public static final StoragePoolType EXT = new StoragePoolType("EXT", false, true, false);
        public static final StoragePoolType OCFS2 = new StoragePoolType("OCFS2", true, false, false);
        public static final StoragePoolType SMB = new StoragePoolType("SMB", true, false, false);
        public static final StoragePoolType Gluster = new StoragePoolType("Gluster", true, false, false);
        public static final StoragePoolType PowerFlex = new StoragePoolType("PowerFlex", true, true, true);
        public static final StoragePoolType ManagedNFS = new StoragePoolType("ManagedNFS", true, false, false);
        public static final StoragePoolType Linstor = new StoragePoolType("Linstor", true, true, false);
        public static final StoragePoolType DatastoreCluster = new StoragePoolType("DatastoreCluster", true, true, false);
        public static final StoragePoolType StorPool = new StoragePoolType("StorPool", true,true,true);
        public static final StoragePoolType FiberChannel = new StoragePoolType("FiberChannel", true,true,false);


        private final String name;
        private final boolean shared;
        private final boolean overprovisioning;
        private final boolean encryption;

        /**
         * New StoragePoolType, set the name to check with it in Dao (Note: Do not register it into the map of pool types).
         * @param name name of the StoragePoolType.
         */
        public StoragePoolType(String name) {
            this.name = name;
            this.shared = false;
            this.overprovisioning = false;
            this.encryption = false;
        }

        /**
         * Define a new StoragePoolType, and register it into the map of pool types known to the management server.
         * @param name Simple unique name of the StoragePoolType.
         * @param shared Storage pool is shared/accessible to multiple hypervisors
         * @param overprovisioning Storage pool supports overprovisioning
         * @param encryption Storage pool supports encrypted volumes
         */
        public StoragePoolType(String name, boolean shared, boolean overprovisioning, boolean encryption) {
            this.name = name;
            this.shared = shared;
            this.overprovisioning = overprovisioning;
            this.encryption = encryption;
            addStoragePoolType(this);
        }

        public boolean isShared() {
            return shared;
        }

        public boolean supportsOverProvisioning() {
            return overprovisioning;
        }

        public boolean supportsEncryption() { return encryption; }

        private static void addStoragePoolType(StoragePoolType storagePoolType) {
            map.putIfAbsent(storagePoolType.name, storagePoolType);
        }

        public static StoragePoolType[] values() {
            return map.values().toArray(StoragePoolType[]::new).clone();
        }

        public static StoragePoolType valueOf(String name) {
            if (StringUtils.isBlank(name)) {
                return null;
            }

            StoragePoolType storage = map.get(name);
            if (storage == null) {
                throw new IllegalArgumentException("StoragePoolType '" + name + "' not found");
            }
            return storage;
        }

        @Override
        public String toString() {
            return name;
        }

        public String name() {
            return name;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            StoragePoolType that = (StoragePoolType) o;
            return Objects.equals(name, that.name);
        }

        @Override
        public int hashCode() {
            return Objects.hash(name);
        }
    }

    public static List<StoragePoolType> getNonSharedStoragePoolTypes() {
        List<StoragePoolType> nonSharedStoragePoolTypes = new ArrayList<StoragePoolType>();
        for (StoragePoolType storagePoolType : StoragePoolType.values()) {
            if (!storagePoolType.isShared()) {
                nonSharedStoragePoolTypes.add(storagePoolType);
            }
        }
        return nonSharedStoragePoolTypes;

    }

    public static enum StorageResourceType {
        STORAGE_POOL, STORAGE_HOST, SECONDARY_STORAGE, LOCAL_SECONDARY_STORAGE
    }
}