Devicegraph.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_DEVICEGRAPH_H
#define STORAGE_DEVICEGRAPH_H
 
 
#include <boost/noncopyable.hpp>
 
#include "storage/Devices/Device.h"
#include "storage/Graphviz.h"
#include "storage/Utils/Swig.h"
#include "storage/UsedFeatures.h"
 
 
namespace storage
{
    class Storage;
    class Device;
    class Holder;
    class Disk;
    class Md;
    class LvmVg;
    class Filesystem;
    class BlkFilesystem;
    class CheckCallbacks;
 
 
    class DeviceNotFound : public Exception
    {
    public:
 
        DeviceNotFound(const std::string& msg);
    };
 
 
    class DeviceNotFoundBySid : public DeviceNotFound
    {
    public:
 
        DeviceNotFoundBySid(sid_t sid);
    };
 
 
    class DeviceNotFoundByName : public DeviceNotFound
    {
    public:
 
        DeviceNotFoundByName(const std::string& name);
    };
 
 
    class DeviceNotFoundByUuid : public DeviceNotFound
    {
    public:
 
        DeviceNotFoundByUuid(const std::string& uuid);
    };
 
 
    class ST_DEPRECATED HolderNotFound: public Exception
    {
    public:
 
        HolderNotFound(const std::string& msg);
    };
 
 
    class ST_DEPRECATED HolderNotFoundBySids : public HolderNotFound
    {
    public:
 
        HolderNotFoundBySids(sid_t source_sid, sid_t target_sid);
    };
 
 
    class HolderAlreadyExists : public Exception
    {
    public:
 
        HolderAlreadyExists(sid_t source_sid, sid_t target_sid);
    };
 
 
    class WrongNumberOfParents : public Exception
    {
    public:
 
        WrongNumberOfParents(size_t seen, size_t expected);
    };
 
 
    class WrongNumberOfChildren : public Exception
    {
    public:
 
        WrongNumberOfChildren(size_t seen, size_t expected);
    };
 
 
    class WrongNumberOfHolders : public Exception
    {
    public:
 
        WrongNumberOfHolders(size_t seen, size_t expected);
    };
 
 
    class Devicegraph : private boost::noncopyable
    {
 
    public:
 
        Devicegraph(Storage* storage);
        ~Devicegraph();
 
        bool operator==(const Devicegraph& rhs) const;
        bool operator!=(const Devicegraph& rhs) const;
 
        Storage* get_storage();
 
        const Storage* get_storage() const;
 
        void load(const std::string& filename);
 
        void save(const std::string& filename) const;
 
        bool empty() const;
 
        size_t num_devices() const;
 
        size_t num_holders() const;
 
        Device* find_device(sid_t sid);
 
        const Device* find_device(sid_t sid) const;
 
        bool device_exists(sid_t sid) const;
 
        bool holder_exists(sid_t source_sid, sid_t target_sid) const;
 
        void clear();
 
        std::vector<Disk*> get_all_disks();
 
        std::vector<const Disk*> get_all_disks() const;
 
        std::vector<Md*> get_all_mds();
 
        std::vector<const Md*> get_all_mds() const;
 
        std::vector<LvmVg*> get_all_lvm_vgs();
 
        std::vector<const LvmVg*> get_all_lvm_vgs() const;
 
        std::vector<Filesystem*> get_all_filesystems();
 
        std::vector<const Filesystem*> get_all_filesystems() const;
 
        std::vector<BlkFilesystem*> get_all_blk_filesystems();
 
        std::vector<const BlkFilesystem*> get_all_blk_filesystems() const;
 
        void remove_device(sid_t sid);
 
        void remove_device(Device* a);
 
        void remove_devices(std::vector<Device*> devices);
 
        Holder* find_holder(sid_t source_sid, sid_t target_sid);
 
        const Holder* find_holder(sid_t source_sid, sid_t target_sid) const;
 
        std::vector<Holder*> find_holders(sid_t source_sid, sid_t target_sid);
 
        std::vector<const Holder*> find_holders(sid_t source_sid, sid_t target_sid) const;
 
        void remove_holder(Holder* holder);
 
        void check(const CheckCallbacks* check_callbacks = nullptr) const;
 
        uint64_t used_features() const ST_DEPRECATED;
 
        uf_t used_features(UsedFeaturesDependencyType used_features_dependency_type) const;
 
        // TODO move to Impl
        void copy(Devicegraph& dest) const;
 
        void write_graphviz(const std::string& filename, DevicegraphStyleCallbacks* style_callbacks, View view) const;
 
        void write_graphviz(const std::string& filename, DevicegraphStyleCallbacks* style_callbacks) const ST_DEPRECATED;
 
        void write_graphviz(const std::string& filename, GraphvizFlags flags = GraphvizFlags::NAME,
                            GraphvizFlags tooltip_flags = GraphvizFlags::NONE) const ST_DEPRECATED;
 
        friend std::ostream& operator<<(std::ostream& out, const Devicegraph& devicegraph);
 
    public:
 
        class Impl;
 
        Impl& get_impl() { return *impl; }
        const Impl& get_impl() const { return *impl; }
 
    private:
 
        const std::unique_ptr<Impl> impl;
 
    };
 
}
 
#endif