LvmLv.h

/*
 * Copyright (c) [2016-2021] SUSE LLC
 *
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of version 2 of the GNU General Public License as published
 * by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, contact Novell, Inc.
 *
 * To contact Novell about this file by physical or electronic mail, you may
 * find current contact information at www.novell.com.
 */
 
 
#ifndef STORAGE_LVM_LV_H
#define STORAGE_LVM_LV_H
 
 
#include "storage/Devices/BlkDevice.h"
#include "storage/Devicegraph.h"
 
 
namespace storage
{
 
    class LvmVg;
 

    enum class LvType
    {
        UNKNOWN,

        NORMAL,

        THIN_POOL,

        THIN,

        RAID,

        CACHE_POOL,

        CACHE,

        WRITECACHE,

        SNAPSHOT,

        MIRROR
    };
 

    std::string get_lv_type_name(LvType lv_type);
 
 
    class LvmLvNotFoundByLvName : public DeviceNotFound
    {
    public:
 
        LvmLvNotFoundByLvName(const std::string& lv_name);
    };
 
 
    class InvalidStripeSize : public Exception
    {
    public:
 
        InvalidStripeSize(const std::string& msg);
    };
 
 
    class InvalidChunkSize : public Exception
    {
    public:
 
        InvalidChunkSize(const std::string& msg);
    };
 

    class LvmLv : public BlkDevice
    {
 
    public:

        static LvmLv* create(Devicegraph* devicegraph, const std::string& vg_name,
                             const std::string& lv_name, LvType lv_type);
 
        static LvmLv* load(Devicegraph* devicegraph, const xmlNode* node);

        static std::vector<LvmLv*> get_all(Devicegraph* devicegraph);

        static std::vector<const LvmLv*> get_all(const Devicegraph* devicegraph);

        const std::string& get_lv_name() const;

        void set_lv_name(const std::string& lv_name);

        static bool is_valid_lv_name(const std::string& lv_name);

        LvType get_lv_type() const;

        unsigned int get_stripes() const;

        void set_stripes(unsigned int stripes);

        unsigned long long get_stripe_size() const;

        void set_stripe_size(unsigned long long stripe_size);

        unsigned long long get_chunk_size() const;

        void set_chunk_size(unsigned long long chunk_size);

        const LvmVg* get_lvm_vg() const;

        const LvmLv* get_thin_pool() const;

        bool has_snapshots() const;

        std::vector<LvmLv*> get_snapshots();

        std::vector<const LvmLv*> get_snapshots() const;

        bool has_origin() const;

        LvmLv* get_origin();

        const LvmLv* get_origin() const;

        unsigned long long max_size_for_lvm_lv(LvType lv_type) const;

        LvmLv* create_lvm_lv(const std::string& lv_name, LvType lv_type, unsigned long long size);

        LvmLv* get_lvm_lv(const std::string& lv_name);
 
        std::vector<LvmLv*> get_lvm_lvs();
        std::vector<const LvmLv*> get_lvm_lvs() const;

        static bool compare_by_lv_name(const LvmLv* lhs, const LvmLv* rhs);
 
    public:
 
        class Impl;
 
        Impl& get_impl();
        const Impl& get_impl() const;
 
        virtual LvmLv* clone() const override;
        virtual std::unique_ptr<Device> clone_v2() const override;
 
        LvmLv(Impl* impl);
        ST_NO_SWIG LvmLv(std::unique_ptr<Device::Impl>&& impl);
 
    };
 

    bool is_lvm_lv(const Device* device);

    LvmLv* to_lvm_lv(Device* device);

    const LvmLv* to_lvm_lv(const Device* device);
 
}
 
#endif