Storage.h

/*
 * Copyright (c) [2014-2015] Novell, Inc.
 * Copyright (c) [2016-2020] 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 <utility>
#include <memory>
#include <boost/noncopyable.hpp>
 
#include "storage/Filesystems/Mountable.h"
#include "storage/CommitOptions.h"
#include "storage/Utils/Callbacks.h"
 
 
namespace storage
{
    class Environment;
    class Arch;
    class Devicegraph;
    class Actiongraph;
    class Pool;
 
 
    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;
 
        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& info, int attempt) const = 0;
 
    };
 
 
    struct DeactivateStatus
    {
        bool multipath;
        bool dm_raid;
        bool md;
        bool lvm_lv;
        bool luks;
        // TODO add bcache?
    };
 
 
    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 CheckCallbacks
    {
    public:
 
        virtual ~CheckCallbacks() {}
 
        virtual void error(const std::string& message) const = 0;
 
    };
 
 
    class CommitCallbacks : public Callbacks
    {
    public:
 
        virtual ~CommitCallbacks() {}
 
    };
 
 
    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);
 
        std::string prepend_rootprefix(const std::string& mount_point) const;
 
        const Actiongraph* calculate_actiongraph();
 
        void activate(const ActivateCallbacks* activate_callbacks) const;
 
        DeactivateStatus deactivate() 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);
 
        bool exists_pool(const std::string& name) const;
 
        std::vector<std::string> get_pool_names() const ST_DEPRECATED;
 
        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