Storage.h

/*
 * Copyright (c) [2014-2015] Novell, Inc.
 * Copyright (c) [2016-2023] 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_STORAGE_H
#define STORAGE_STORAGE_H


#include <string>
#include <vector>
#include <map>
#include <utility>
#include <memory>
#include <boost/noncopyable.hpp>

#include "storage/CommitOptions.h"
#include "storage/Actions/Base.h"
#include "storage/Utils/Callbacks.h"
#include "storage/Utils/Swig.h"


namespace storage
{
    class Environment;
    class Arch;
    class Devicegraph;
    class Actiongraph;
    class Pool;
    enum class PtType;
    enum class FsType;
    enum class MountByType;


    class ActivateCallbacks : public Callbacks
    {
    public:

        virtual ~ActivateCallbacks() {}

        virtual bool multipath(bool looks_like_real_multipath) const = 0;

        virtual std::pair<bool, std::string> luks(const std::string& uuid, int attempt) const = 0;

    };


    class LuksInfo : private boost::noncopyable
    {
    public:

        LuksInfo();
        ~LuksInfo();

        const std::string& get_device_name() const;
        unsigned long long get_size() const;
        const std::string& get_dm_table_name() const;
        bool is_dm_table_name_generated() const;
        const std::string& get_uuid() const;
        const std::string& get_label() const;

    public:

        class Impl;

        Impl& get_impl() { return *impl; }
        const Impl& get_impl() const { return *impl; }

    private:

        const std::unique_ptr<Impl> impl;

    };


    class ActivateCallbacksLuks : public ActivateCallbacks
    {
    public:

        virtual ~ActivateCallbacksLuks() {}

        virtual std::pair<bool, std::string> luks(const LuksInfo& luks_info, int attempt) const = 0;

    };


    class BitlockerInfo : private boost::noncopyable
    {
    public:

        BitlockerInfo();
        ~BitlockerInfo();

        const std::string& get_device_name() const;
        unsigned long long get_size() const;
        const std::string& get_dm_table_name() const;
        bool is_dm_table_name_generated() const;
        const std::string& get_uuid() const;

    public:

        class Impl;

        Impl& get_impl() { return *impl; }
        const Impl& get_impl() const { return *impl; }

    private:

        const std::unique_ptr<Impl> impl;

    };


    class ActivateCallbacksV3 : public ActivateCallbacksLuks
    {
    public:

        virtual ~ActivateCallbacksV3() {}

        virtual void begin() const {}

        virtual void end() const {}

        virtual std::pair<bool, std::string> bitlocker(const BitlockerInfo& bitlocker_info, int attempt) const = 0;

    };


    struct ST_DEPRECATED DeactivateStatus
    {
        bool multipath;
        bool dm_raid;
        bool md;
        bool lvm_lv;
        bool luks;
    };


    class DeactivateStatusV2
    {
    public:

        DeactivateStatusV2();
        DeactivateStatusV2(const DeactivateStatusV2& deactivate_status);
        virtual ~DeactivateStatusV2();

        DeactivateStatusV2& operator=(const DeactivateStatusV2& deactivate_status);

        bool multipath() const;
        bool dm_raid() const;
        bool md() const;
        bool lvm_lv() const;
        bool luks() const;
        bool bitlocker() const;

    public:

        class Impl;

        Impl& get_impl() { return *impl; }
        const Impl& get_impl() const { return *impl; }

    private:

        const std::unique_ptr<Impl> impl;

    };


    class ProbeCallbacks : public Callbacks
    {
    public:

        virtual ~ProbeCallbacks() {}

    };


    class ProbeCallbacksV2 : public ProbeCallbacks
    {
    public:

        virtual ~ProbeCallbacksV2() {}

        virtual bool missing_command(const std::string& message, const std::string& what,
                                     const std::string& command, uint64_t used_features) const = 0;

    };


    class ProbeCallbacksV3 : public ProbeCallbacksV2
    {
    public:

        virtual ~ProbeCallbacksV3() {}

        virtual void begin() const {}

        virtual void end() const {}

    };


    class ProbeCallbacksV4 : public ProbeCallbacksV3
    {
    public:

        virtual ~ProbeCallbacksV4() {}

        virtual bool ambiguity_partition_table_and_filesystem(const std::string& message, const std::string& what,
                                                              const std::string& name, PtType pt_type,
                                                              FsType fs_type) const = 0;

        virtual bool ambiguity_partition_table_and_luks(const std::string& message, const std::string& what,
                                                        const std::string& name, PtType pt_type) const = 0;

        virtual bool ambiguity_partition_table_and_lvm_pv(const std::string& message, const std::string& what,
                                                          const std::string& name, PtType pt_type) const = 0;

        virtual bool unsupported_partition_table(const std::string& message, const std::string& what,
                                                 const std::string& name, PtType pt_type) const = 0;

        virtual bool unsupported_filesystem(const std::string& message, const std::string& what,
                                            const std::string& name, FsType fs_type) const = 0;

    };


    class CheckCallbacks
    {
    public:

        virtual ~CheckCallbacks() {}

        virtual void error(const std::string& message) const = 0;

    };


    class CommitCallbacks : public Callbacks
    {
    public:

        virtual ~CommitCallbacks() {}

    };


    class CommitCallbacksV2 : public CommitCallbacks
    {
    public:

        virtual void begin() const {}

        virtual void end() const {}

        virtual void begin_action(const Action::Base* action) const {}

        virtual void end_action(const Action::Base* action) const {}

        virtual ~CommitCallbacksV2() {}

    };

    class Storage : private boost::noncopyable
    {
    public:

        Storage(const Environment& environment);

        ~Storage();

    public:

        const Environment& get_environment() const;
        const Arch& get_arch() const;

        Devicegraph* create_devicegraph(const std::string& name);

        Devicegraph* copy_devicegraph(const std::string& source_name, const std::string& dest_name);

        void remove_devicegraph(const std::string& name);

        void restore_devicegraph(const std::string& name);

        bool equal_devicegraph(const std::string& lhs, const std::string& rhs) const;

        bool exist_devicegraph(const std::string& name) const;

        std::vector<std::string> get_devicegraph_names() const ST_DEPRECATED;

        std::map<std::string, const Devicegraph*> get_devicegraphs() const;

        Devicegraph* get_devicegraph(const std::string& name);

        const Devicegraph* get_devicegraph(const std::string& name) const;

        Devicegraph* get_staging();

        const Devicegraph* get_staging() const;

        const Devicegraph* get_probed() const;

        Devicegraph* get_system();

        const Devicegraph* get_system() const;

        void check(const CheckCallbacks* check_callbacks = nullptr) const;

        MountByType get_default_mount_by() const;

        void set_default_mount_by(MountByType default_mount_by);

        const std::string& get_rootprefix() const;
        void set_rootprefix(const std::string& rootprefix) ST_DEPRECATED;

        std::string prepend_rootprefix(const std::string& mount_point) const;

        const Actiongraph* calculate_actiongraph();

        void activate(const ActivateCallbacks* activate_callbacks) const;

        DeactivateStatus deactivate() const ST_DEPRECATED;

        DeactivateStatusV2 deactivate_v2() const;

        void probe(const ProbeCallbacks* probe_callbacks = nullptr);

        void commit(const CommitOptions& commit_options, const CommitCallbacks* commit_callbacks = nullptr);

        void commit(const CommitCallbacks* commit_callbacks = nullptr) ST_DEPRECATED;

        void generate_pools(const Devicegraph* devicegraph);

        Pool* create_pool(const std::string& name);

        void remove_pool(const std::string& name);

        void rename_pool(const std::string& old_name, const std::string& new_name);

        bool exists_pool(const std::string& name) const;

        std::vector<std::string> get_pool_names() const ST_DEPRECATED;

        std::map<std::string, Pool*> get_pools();

        std::map<std::string, const Pool*> get_pools() const;

        Pool* get_pool(const std::string& name);

        const Pool* get_pool(const std::string& name) const;

    public:

        class Impl;

        Impl& get_impl() { return *impl; }
        const Impl& get_impl() const { return *impl; }

    private:

        const std::unique_ptr<Impl> impl;

    };

}

#endif